1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /* 18 * NFC Ndef Mapping For Remote Devices. 19 * 20 */ 21 22 #include <phFriNfc_MifStdFormat.h> 23 #include <phFriNfc_MifareStdMap.h> 24 #include <phNfcCompId.h> 25 #include <phNxpExtns_MifareStd.h> 26 27 /**************** local methods used in this file only ************************/ 28 static NFCSTATUS phFriNfc_MifStd_H_RdABlock(phFriNfc_NdefMap_t* NdefMap); 29 static NFCSTATUS phFriNfc_MifStd_H_WrABlock(phFriNfc_NdefMap_t* NdefMap); 30 static NFCSTATUS phFriNfc_MifStd_H_AuthSector(phFriNfc_NdefMap_t* NdefMap); 31 static NFCSTATUS phFriNfc_MifStd4k_H_CheckNdef(phFriNfc_NdefMap_t* NdefMap); 32 static void phFriNfc_MifStd_H_fillAIDarray(phFriNfc_NdefMap_t* NdefMap); 33 static uint8_t phFriNfc_MifStd_H_GetSect(uint8_t BlockNumber); 34 static NFCSTATUS phFriNfc_MifStd_H_BlkChk(phFriNfc_NdefMap_t* NdefMap); 35 static NFCSTATUS phFriNfc_MifStd_H_RdAcsBit(phFriNfc_NdefMap_t* NdefMap); 36 static NFCSTATUS phFriNfc_MifStd_H_ChkAcsBit(phFriNfc_NdefMap_t* NdefMap); 37 static NFCSTATUS phFriNfc_MifStd_H_ChkRdWr(phFriNfc_NdefMap_t* NdefMap); 38 static void phFriNfc_MifStd_H_ChkNdefCmpltSects(phFriNfc_NdefMap_t* NdefMap); 39 static NFCSTATUS phFriNfc_MifStd_H_RemainTLV(phFriNfc_NdefMap_t* NdefMap, 40 uint8_t* Flag, 41 uint8_t* Temp16Bytes); 42 static NFCSTATUS phFriNfc_MifStd_H_ChkIntLen(phFriNfc_NdefMap_t* NdefMap); 43 static NFCSTATUS phFriNfc_MifStd_H_IntLenWioutNdef(phFriNfc_NdefMap_t* NdefMap, 44 uint8_t* Flag, 45 uint8_t* TempintBytes); 46 static uint8_t phFriNfc_MifStd_H_UpdateTLV(phFriNfc_NdefMap_t* NdefMap); 47 static NFCSTATUS phFriNfc_MifStd_H_WriteNdefLen(phFriNfc_NdefMap_t* NdefMap); 48 static void phFriNfc_MifStd_H_SetNdefBlkAuth(phFriNfc_NdefMap_t* NdefMap); 49 static void phFriNfc_MifStd_H_RdWrReset(phFriNfc_NdefMap_t* NdefMap); 50 static NFCSTATUS phFriNfc_MifStd_H_RdtoWrNdefLen(phFriNfc_NdefMap_t* NdefMap); 51 static NFCSTATUS phFriNfc_MifStd_H_GetActCardLen(phFriNfc_NdefMap_t* NdefMap); 52 static NFCSTATUS phFriNfc_MifStd_H_ChkTLVs(phFriNfc_NdefMap_t* NdefMap, 53 uint8_t* CRFlag); 54 static NFCSTATUS phFriNfc_MifStd_H_GetNxtTLV(phFriNfc_NdefMap_t* NdefMap, 55 uint16_t* TempLength, 56 uint8_t* TL4bytesFlag); 57 static NFCSTATUS phFriNfc_MifStd_H_Chk16Bytes(phFriNfc_NdefMap_t* NdefMap, 58 uint16_t TempLength); 59 static NFCSTATUS phFriNfc_MifStd_H_ChkRemainTLVs(phFriNfc_NdefMap_t* NdefMap, 60 uint8_t* CRFlag, 61 uint8_t* NDEFFlag); 62 static void phFriNfc_MifStd_H_Complete(phFriNfc_NdefMap_t* NdefMap, 63 NFCSTATUS Result); 64 static void phFriNfc_MifStd_H_Get1kStTrail(phFriNfc_NdefMap_t* NdefMap); 65 static void phFriNfc_MifStd_H_Get4kStTrail(phFriNfc_NdefMap_t* NdefMap); 66 static NFCSTATUS phFriNfc_MifStd_H_ProChkNdef(phFriNfc_NdefMap_t* NdefMap); 67 static NFCSTATUS phFriNfc_MifStd_H_ProAuth(phFriNfc_NdefMap_t* NdefMap); 68 static NFCSTATUS phFriNfc_MifStd_H_Rd16Bytes(phFriNfc_NdefMap_t* NdefMap, 69 uint8_t BlockNo); 70 static NFCSTATUS phFriNfc_MifStd_H_ProAcsBits(phFriNfc_NdefMap_t* NdefMap); 71 static NFCSTATUS phFriNfc_MifStd_H_GPBChk(phFriNfc_NdefMap_t* NdefMap); 72 static NFCSTATUS phFriNfc_MifStd_H_ProStatNotValid(phFriNfc_NdefMap_t* NdefMap, 73 NFCSTATUS status); 74 static NFCSTATUS phFriNfc_MifStd_H_RdBeforeWr(phFriNfc_NdefMap_t* NdefMap); 75 static NFCSTATUS phFriNfc_MifStd_H_ProBytesToWr(phFriNfc_NdefMap_t* NdefMap); 76 static NFCSTATUS phFriNfc_MifStd_H_fillSendBuf(phFriNfc_NdefMap_t* NdefMap, 77 uint8_t Length); 78 static NFCSTATUS phFriNfc_MifStd_H_WrTLV(phFriNfc_NdefMap_t* NdefMap); 79 static NFCSTATUS phFriNfc_MifStd_H_ProWrTLV(phFriNfc_NdefMap_t* NdefMap); 80 static uint8_t phFriNfc_MifStd_H_UpdRemTLV(phFriNfc_NdefMap_t* NdefMap); 81 static void phFriNfc_MifStd_H_fillTLV1(phFriNfc_NdefMap_t* NdefMap); 82 static void phFriNfc_MifStd_H_fillTLV2(phFriNfc_NdefMap_t* NdefMap); 83 static NFCSTATUS phFriNfc_MifStd_H_CallWrNdefLen(phFriNfc_NdefMap_t* NdefMap); 84 static NFCSTATUS phFriNfc_MifStd_H_BlkChk_1(phFriNfc_NdefMap_t* NdefMap); 85 static void phFriNfc_MifStd_H_fillTLV1_1(phFriNfc_NdefMap_t* NdefMap); 86 static void phFriNfc_MifStd_H_fillTLV2_1(phFriNfc_NdefMap_t* NdefMap); 87 static NFCSTATUS phFriNfc_MifStd_H_RdTLV(phFriNfc_NdefMap_t* NdefMap); 88 static NFCSTATUS phFriNfc_MifStd_H_ProRdTLV(phFriNfc_NdefMap_t* NdefMap); 89 static NFCSTATUS phFriNfc_MifStd_H_WrTermTLV(phFriNfc_NdefMap_t* NdefMap); 90 static NFCSTATUS phFriNfc_MifStd_H_ProWrABlock(phFriNfc_NdefMap_t* NdefMap); 91 static NFCSTATUS phFriNfc_MifStd_H_CallConnect(phFriNfc_NdefMap_t* NdefMap); 92 static NFCSTATUS phFriNfc_MifStd_H_CallDisCon(phFriNfc_NdefMap_t* NdefMap); 93 static void phFriNfc_MifStd1k_H_BlkChk(phFriNfc_NdefMap_t* NdefMap, 94 uint8_t SectorID, uint8_t* callbreak); 95 static uint8_t phFriNfc_MifStd_H_GetSectorTrailerBlkNo(uint8_t SectorID); 96 static NFCSTATUS phFriNfc_MifStd_H_ProSectorTrailorAcsBits( 97 phFriNfc_NdefMap_t* NdefMap); 98 static NFCSTATUS phFriNfc_MifStd_H_WrSectorTrailorBlock( 99 phFriNfc_NdefMap_t* NdefMap); 100 static NFCSTATUS phFriNfc_MifStd_H_ProWrSectorTrailor( 101 phFriNfc_NdefMap_t* NdefMap); 102 static NFCSTATUS phFriNfc_MapTool_ChkSpcVer(const phFriNfc_NdefMap_t* NdefMap, 103 uint8_t VersionIndex) 104 __attribute__((unused)); 105 106 /* Mifare Standard Mapping - Constants */ 107 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT1 \ 108 0xA0 /* internal Authenticate Command for MAD Sector */ 109 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT2 \ 110 0xA1 /* internal Authenticate Command for MAD Sector */ 111 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT3 \ 112 0xA2 /* internal Authenticate Command for MAD Sector */ 113 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT4 \ 114 0xA3 /* internal Authenticate Command for MAD Sector */ 115 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT5 \ 116 0xA4 /* internal Authenticate Command for MAD Sector */ 117 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT6 \ 118 0xA5 /* internal Authenticate Command for MAD Sector */ 119 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT1 \ 120 0xD3 /* internal Authenticate Command for NDEF Sectors 1 */ 121 #define PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT2 \ 122 0xF7 /* internal Authenticate Command for NDEF Sectors 2 */ 123 #define PH_FRINFC_NDEFMAP_MIFARESTD_NDEF_COMPVAL2 \ 124 0x03 /* internal Ndef Compliant command 1 */ 125 #define PH_FRINFC_NDEFMAP_MIFARESTD_NDEF_COMPVAL1 \ 126 0xE1 /* internal Ndef Compliant command 2 */ 127 128 /* Enable access bits check for the MAD sector 129 #define ENABLE_ACS_BIT_CHK_FOR_MAD */ 130 131 #define PH_FRINFC_NDEFMAP_MFUL_VAL0 0 132 133 /****************************************************************************** 134 * Function phFriNfc_MapTool_SetCardState 135 * 136 * Description This function sets the appropriate card state. 137 * 138 * Returns This function return NFCSTATUS_SUCCESS in case of success 139 * In case of failure returns other failure value. 140 * 141 ******************************************************************************/ 142 NFCSTATUS phFriNfc_MapTool_SetCardState(phFriNfc_NdefMap_t* NdefMap, 143 uint32_t Length) { 144 NFCSTATUS Result = NFCSTATUS_SUCCESS; 145 146 if (Length == PH_FRINFC_NDEFMAP_MFUL_VAL0) { 147 /* As the NDEF LEN / TLV Len is Zero, irrespective of any state the card 148 shall be set to INITIALIZED STATE*/ 149 NdefMap->CardState = 150 (uint8_t)(((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY) || 151 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID)) 152 ? PH_NDEFMAP_CARD_STATE_INVALID 153 : PH_NDEFMAP_CARD_STATE_INITIALIZED); 154 } else { 155 switch (NdefMap->CardState) { 156 case PH_NDEFMAP_CARD_STATE_INITIALIZED: 157 NdefMap->CardState = 158 (uint8_t)((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) 159 ? NdefMap->CardState 160 : PH_NDEFMAP_CARD_STATE_READ_WRITE); 161 break; 162 163 case PH_NDEFMAP_CARD_STATE_READ_ONLY: 164 NdefMap->CardState = 165 (uint8_t)((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) 166 ? NdefMap->CardState 167 : PH_NDEFMAP_CARD_STATE_READ_ONLY); 168 break; 169 170 case PH_NDEFMAP_CARD_STATE_READ_WRITE: 171 NdefMap->CardState = 172 (uint8_t)((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) 173 ? NdefMap->CardState 174 : PH_NDEFMAP_CARD_STATE_READ_WRITE); 175 if (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD || 176 NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD || 177 NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD) { 178 if (NdefMap->StdMifareContainer.ReadOnlySectorIndex && 179 NdefMap->StdMifareContainer.SectorTrailerBlockNo == 180 NdefMap->StdMifareContainer.currentBlock) { 181 NdefMap->CardState = 182 (uint8_t)((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) 183 ? NdefMap->CardState 184 : PH_NDEFMAP_CARD_STATE_READ_ONLY); 185 } 186 } 187 break; 188 189 default: 190 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID; 191 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT); 192 break; 193 } 194 } 195 Result = ((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) 196 ? PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT) 197 : Result); 198 199 return Result; 200 } 201 202 /****************************************************************************** 203 * Function phFriNfc_MifareStdMap_H_Reset 204 * 205 * Description This function resets the component instance to the initial 206 * state and lets the component forget about the list of 207 * registered items. Moreover, the lower device is set. 208 * 209 * Returns This function return NFCSTATUS_SUCCESS in case of success 210 * In case of failure returns other failure value. 211 * 212 ******************************************************************************/ 213 NFCSTATUS phFriNfc_MifareStdMap_H_Reset(phFriNfc_NdefMap_t* NdefMap) { 214 NFCSTATUS status = NFCSTATUS_SUCCESS; 215 uint8_t index = PH_FRINFC_MIFARESTD_VAL0; 216 217 if (NdefMap == NULL) { 218 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 219 } else { 220 /* Current Block stores the present block accessed in the card */ 221 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_VAL0; 222 223 for (index = PH_FRINFC_MIFARESTD_VAL0; 224 index < PH_FRINFC_NDEFMAP_MIFARESTD_ST15_BYTES; index++) { 225 /* internal buffer to store the odd bytes of length < 15 */ 226 NdefMap->StdMifareContainer.internalBuf[index] = PH_FRINFC_MIFARESTD_VAL0; 227 } 228 229 for (index = 0; index < PH_FRINFC_NDEFMAP_MIFARESTD_TOTALNO_BLK; index++) { 230 /* aid buffer reset to non ndef compliant */ 231 NdefMap->StdMifareContainer.aid[index] = 232 PH_FRINFC_MIFARESTD_NON_NDEF_COMP; 233 } 234 235 /* odd bytes length stored in the internal buffer */ 236 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 237 238 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED; 239 240 /* Flag to get that last few bytes are taken from the user buffer */ 241 NdefMap->StdMifareContainer.RemainingBufFlag = PH_FRINFC_MIFARESTD_FLAG0; 242 243 /* Flag to find that the read/write operation has reached the end of the 244 card. Further reading/writing is not possible */ 245 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 246 PH_FRINFC_MIFARESTD_FLAG0; 247 248 /* Flag to get that last few bytes are taken from the internal buffer */ 249 NdefMap->StdMifareContainer.internalBufFlag = PH_FRINFC_MIFARESTD_FLAG0; 250 251 /* Authentication Flag for every sector */ 252 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 253 254 /* Used in Check Ndef for storing the sector ID */ 255 NdefMap->StdMifareContainer.SectorIndex = PH_FRINFC_MIFARESTD_VAL0; 256 257 NdefMap->StdMifareContainer.NdefBlocks = PH_FRINFC_MIFARESTD_VAL0; 258 259 NdefMap->StdMifareContainer.NoOfNdefCompBlocks = PH_FRINFC_MIFARESTD_VAL0; 260 261 NdefMap->StdMifareContainer.ReadAcsBitFlag = PH_FRINFC_MIFARESTD_FLAG0; 262 263 NdefMap->StdMifareContainer.remSizeUpdFlag = PH_FRINFC_MIFARESTD_FLAG0; 264 265 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL0; 266 267 NdefMap->TLVStruct.prevLenByteValue = PH_FRINFC_MIFARESTD_VAL0; 268 269 NdefMap->TLVStruct.BytesRemainLinTLV = PH_FRINFC_MIFARESTD_VAL0; 270 271 NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_MIFARESTD_VAL0; 272 273 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL0; 274 275 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 276 277 NdefMap->StdMifareContainer.remainingSize = PH_FRINFC_MIFARESTD_VAL0; 278 279 NdefMap->StdMifareContainer.ReadNdefFlag = PH_FRINFC_MIFARESTD_FLAG0; 280 281 NdefMap->StdMifareContainer.WrNdefFlag = PH_FRINFC_MIFARESTD_FLAG0; 282 283 NdefMap->StdMifareContainer.ChkNdefFlag = PH_FRINFC_MIFARESTD_FLAG0; 284 285 NdefMap->StdMifareContainer.aidCompleteFlag = PH_FRINFC_MIFARESTD_FLAG0; 286 287 NdefMap->StdMifareContainer.NFCforumSectFlag = PH_FRINFC_MIFARESTD_FLAG0; 288 289 NdefMap->StdMifareContainer.ProprforumSectFlag = 290 PH_FRINFC_MIFARESTD_PROP_1ST_CONFIG; 291 292 NdefMap->StdMifareContainer.ReadCompleteFlag = PH_FRINFC_MIFARESTD_FLAG0; 293 294 NdefMap->StdMifareContainer.FirstReadFlag = PH_FRINFC_MIFARESTD_FLAG0; 295 296 NdefMap->StdMifareContainer.WrLength = PH_FRINFC_MIFARESTD_VAL1; 297 298 NdefMap->StdMifareContainer.ChkNdefCompleteFlag = PH_FRINFC_MIFARESTD_FLAG0; 299 300 NdefMap->StdMifareContainer.ReadOnlySectorIndex = PH_FRINFC_MIFARESTD_FLAG0; 301 302 NdefMap->StdMifareContainer.TotalNoSectors = PH_FRINFC_MIFARESTD_FLAG0; 303 304 NdefMap->StdMifareContainer.SectorTrailerBlockNo = 305 PH_FRINFC_MIFARESTD_FLAG0; 306 } 307 308 return status; 309 } 310 311 /****************************************************************************** 312 * Function phFriNfc_MifareStdMap_ChkNdef 313 * 314 * Description The function checks whether the peer device is NDEF 315 *compliant. 316 * 317 * Returns This function return NFCSTATUS_PENDING in case of success 318 * In case of failure returns other failure value. 319 * 320 ******************************************************************************/ 321 NFCSTATUS phFriNfc_MifareStdMap_ChkNdef(phFriNfc_NdefMap_t* NdefMap) { 322 NFCSTATUS status = NFCSTATUS_PENDING; 323 uint8_t atq, sak; 324 325 if (NdefMap == NULL) { 326 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 327 } else { 328 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE; 329 NdefMap->StdMifareContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_CHK_NDEF; 330 331 /* Get the Select Response and Sense Response to get 332 the exact Card Type either Mifare 1k or 4k */ 333 sak = NdefMap->psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.Sak; 334 atq = NdefMap->psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.AtqA[0]; 335 336 if (0x08 == (sak & 0x18)) { 337 /* Total Number of Blocks in Mifare 1k Card */ 338 NdefMap->StdMifareContainer.NoOfNdefCompBlocks = 339 PH_FRINFC_NDEFMAP_MIFARESTD_1KNDEF_COMPBLOCK; 340 NdefMap->StdMifareContainer.remainingSize = 341 ((NdefMap->CardType == PH_FRINFC_MIFARESTD_VAL0) 342 ? (PH_FRINFC_NDEFMAP_MIFARESTD_1KNDEF_COMPBLOCK * 343 PH_FRINFC_MIFARESTD_BLOCK_BYTES) 344 : NdefMap->StdMifareContainer.remainingSize); 345 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD; 346 } else if (0x19 == (sak & 0x19)) { 347 /* Total Number of Blocks in Mifare 2k Card */ 348 NdefMap->StdMifareContainer.NoOfNdefCompBlocks = 349 PH_FRINFC_NDEFMAP_MIFARESTD_2KNDEF_COMPBLOCK; 350 NdefMap->StdMifareContainer.remainingSize = 351 ((NdefMap->CardType == PH_FRINFC_MIFARESTD_VAL0) 352 ? (PH_FRINFC_NDEFMAP_MIFARESTD_2KNDEF_COMPBLOCK * 353 PH_FRINFC_MIFARESTD_BLOCK_BYTES) 354 : NdefMap->StdMifareContainer.remainingSize); 355 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD; 356 } else { 357 /* Total Number of Blocks in Mifare 4k Card */ 358 NdefMap->StdMifareContainer.NoOfNdefCompBlocks = 359 PH_FRINFC_NDEFMAP_MIFARESTD_4KNDEF_COMPBLOCK; 360 NdefMap->StdMifareContainer.remainingSize = 361 ((NdefMap->CardType == PH_FRINFC_MIFARESTD_VAL0) 362 ? (PH_FRINFC_NDEFMAP_MIFARESTD_4KNDEF_COMPBLOCK * 363 PH_FRINFC_MIFARESTD_BLOCK_BYTES) 364 : NdefMap->StdMifareContainer.remainingSize); 365 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD; 366 } 367 368 /* phFriNfc_MifareStdMap_ChkNdef should be called only 369 when currentBlock is 0 OR 64,65 and 66 (for Mifare 4k). 370 Otherwise return error */ 371 /* and also Check the Authentication Flag */ 372 if ((NdefMap->StdMifareContainer.currentBlock != 0) && 373 (NdefMap->StdMifareContainer.currentBlock != 1) && 374 (NdefMap->StdMifareContainer.currentBlock != 2) && 375 (NdefMap->StdMifareContainer.currentBlock != 64) && 376 (NdefMap->StdMifareContainer.currentBlock != 65) && 377 (NdefMap->StdMifareContainer.currentBlock != 66)) { 378 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 379 } else if (NdefMap->StdMifareContainer.AuthDone == 0) { 380 /* Block 0 contains Manufacturer information and 381 also other informaton. So go for block 1 which 382 contains AIDs. Authenticating any of the block 383 in a sector, Authenticates the whole sector */ 384 if (NdefMap->StdMifareContainer.currentBlock == 0) { 385 NdefMap->StdMifareContainer.currentBlock = 1; 386 } 387 status = phFriNfc_MifStd_H_AuthSector(NdefMap); 388 } else { 389 /** 390 * Mifare 1k, sak = 0x08 atq = 0x04 391 * Mifare 2k, sak = 0x19 atq = 0x02 392 * Mifare 4k, sak = 0x18 atq = 0x02 393 */ 394 if ((NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD) || 395 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD) || 396 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD)) { 397 /* Change the state to Check Ndef Compliant */ 398 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_CHK_NDEF_COMP; 399 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE; 400 NdefMap->StdMifareContainer.ChkNdefFlag = PH_FRINFC_MIFARESTD_FLAG1; 401 402 NdefMap->MapCompletionInfo.CompletionRoutine = 403 phFriNfc_MifareStdMap_Process; 404 NdefMap->MapCompletionInfo.Context = NdefMap; 405 406 NdefMap->Cmd.MfCmd = phHal_eMifareRead; 407 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 408 NdefMap->SendRecvBuf[0] = NdefMap->StdMifareContainer.currentBlock; 409 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_READ; 410 411 /* Call the Overlapped HAL Transceive function */ 412 status = phFriNfc_ExtnsTransceive( 413 NdefMap->pTransceiveInfo, NdefMap->Cmd, NdefMap->SendRecvBuf, 414 NdefMap->SendLength, NdefMap->SendRecvLength); 415 } else { 416 /* Since we have decided temporarily not to go 417 for any new error codes we are using 418 NFCSTATUS_INVALID_PARAMETER even though it is not 419 the relevant error code here TBD */ 420 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 421 } 422 } 423 } 424 425 return status; 426 } 427 428 /****************************************************************************** 429 * Function phFriNfc_MifareStdMap_RdNdef 430 * 431 * Description The function initiates the reading of NDEF information from 432 * a Remote Device. It performs a reset of the state and starts 433 * the action (state machine). A periodic call of the 434 * phFriNfcNdefMap_Process has to be done once the action 435 * has been triggered. 436 * 437 * Returns This function return NFCSTATUS_PENDING in case of success 438 * In case of failure returns other failure value. 439 * 440 ******************************************************************************/ 441 NFCSTATUS phFriNfc_MifareStdMap_RdNdef(phFriNfc_NdefMap_t* NdefMap, 442 uint8_t* PacketData, 443 uint32_t* PacketDataLength, 444 uint8_t Offset) { 445 NFCSTATUS status = NFCSTATUS_PENDING; 446 447 NdefMap->ApduBufferSize = *PacketDataLength; 448 NdefMap->NumOfBytesRead = PacketDataLength; 449 *NdefMap->NumOfBytesRead = 0; 450 NdefMap->ApduBuffIndex = 0; 451 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE; 452 NdefMap->StdMifareContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_RD_NDEF; 453 454 if ((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) || 455 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INITIALIZED)) { 456 /* Card state is not correct */ 457 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 458 } else { 459 if ((Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || 460 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_WRITE_OPE)) { 461 phFriNfc_MifStd_H_RdWrReset(NdefMap); 462 NdefMap->StdMifareContainer.ReadNdefFlag = PH_FRINFC_MIFARESTD_FLAG1; 463 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 464 } 465 /* Offset = Current, but the read has reached the End of Card */ 466 if ((Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) && 467 (NdefMap->StdMifareContainer.ReadWriteCompleteFlag == 468 PH_FRINFC_MIFARESTD_FLAG1)) { 469 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 470 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); 471 } else { 472 NdefMap->Offset = 473 (((Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN) && 474 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_WRITE_OPE)) 475 ? PH_FRINFC_NDEFMAP_SEEK_BEGIN 476 : Offset); 477 status = phFriNfc_MifStd_H_BlkChk(NdefMap); 478 if (status == NFCSTATUS_SUCCESS) { 479 NdefMap->ApduBuffer = PacketData; 480 481 /* Read Operation in Progress */ 482 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 483 PH_FRINFC_MIFARESTD_FLAG0; 484 485 /* Check Authentication Flag */ 486 status = 487 ((NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1) 488 ? phFriNfc_MifStd_H_RdABlock(NdefMap) 489 : phFriNfc_MifStd_H_AuthSector(NdefMap)); 490 } 491 } 492 } 493 494 return status; 495 } 496 497 /****************************************************************************** 498 * Function phFriNfc_MifareStdMap_WrNdef 499 * 500 * Description The function initiates the writing of NDEF information to 501 * a Remote Device. It performs a reset of the state and starts 502 * the action (state machine). A periodic call of the 503 * phFriNfcNdefMap_Process has to be done once the action 504 * has been triggered. 505 * 506 * Returns This function return NFCSTATUS_PENDING in case of success 507 * In case of failure returns other failure value. 508 * 509 ******************************************************************************/ 510 NFCSTATUS phFriNfc_MifareStdMap_WrNdef(phFriNfc_NdefMap_t* NdefMap, 511 uint8_t* PacketData, 512 uint32_t* PacketDataLength, 513 uint8_t Offset) { 514 NFCSTATUS status = NFCSTATUS_PENDING; 515 516 NdefMap->ApduBuffer = PacketData; 517 NdefMap->ApduBufferSize = *PacketDataLength; 518 NdefMap->ApduBuffIndex = PH_FRINFC_MIFARESTD_VAL0; 519 NdefMap->WrNdefPacketLength = PacketDataLength; 520 *NdefMap->WrNdefPacketLength = PH_FRINFC_MIFARESTD_VAL0; 521 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE; 522 NdefMap->StdMifareContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_WR_NDEF; 523 524 if ((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) || 525 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY)) { 526 /* Card state is not correct */ 527 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 528 } else { 529 if ((Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || 530 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE)) { 531 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 532 NdefMap->StdMifareContainer.RdBeforeWrFlag = PH_FRINFC_MIFARESTD_FLAG1; 533 NdefMap->StdMifareContainer.WrNdefFlag = PH_FRINFC_MIFARESTD_FLAG1; 534 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 535 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 536 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 537 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 538 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL0; 539 NdefMap->TLVStruct.NdefTLVAuthFlag = PH_FRINFC_MIFARESTD_FLAG0; 540 NdefMap->StdMifareContainer.FirstReadFlag = PH_FRINFC_MIFARESTD_FLAG0; 541 NdefMap->StdMifareContainer.remainingSize = 542 (NdefMap->StdMifareContainer.NoOfNdefCompBlocks * 543 PH_FRINFC_MIFARESTD_BLOCK_BYTES); 544 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_BLK4; 545 NdefMap->StdMifareContainer.NdefBlocks = PH_FRINFC_MIFARESTD_VAL1; 546 NdefMap->StdMifareContainer.NFCforumSectFlag = PH_FRINFC_MIFARESTD_FLAG0; 547 /* This macro is added, to be compliant with the previous HAL 2.0 548 For HAL 2.0, polling is done before writing data to the mifare 549 std (if the offset is BEGIN), because if an error is reported 550 during read or write and again write is called, the PN531 state is 551 unchanged (so write will fail), to bring the PN531 to the correct 552 state, polling is done. 553 Changed on 13th Jan 2009 554 */ 555 NdefMap->StdMifareContainer.PollFlag = PH_FRINFC_MIFARESTD_FLAG0; 556 NdefMap->StdMifareContainer.WrLength = PH_FRINFC_MIFARESTD_VAL0; 557 NdefMap->StdMifareContainer.FirstWriteFlag = PH_FRINFC_MIFARESTD_FLAG1; 558 } 559 560 if (((Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) && 561 (NdefMap->StdMifareContainer.ReadWriteCompleteFlag == 562 PH_FRINFC_MIFARESTD_FLAG1)) || 563 ((NdefMap->StdMifareContainer.PollFlag == PH_FRINFC_MIFARESTD_FLAG1) && 564 (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR))) { 565 /* Offset = Current, but the read has reached the End of Card */ 566 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 567 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); 568 } else { 569 NdefMap->Offset = 570 (((Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN) && 571 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE)) 572 ? PH_FRINFC_NDEFMAP_SEEK_BEGIN 573 : Offset); 574 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 575 status = phFriNfc_MifStd_H_BlkChk(NdefMap); 576 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 577 PH_FRINFC_MIFARESTD_FLAG0; 578 if (status == NFCSTATUS_SUCCESS) { 579 if (NdefMap->StdMifareContainer.PollFlag == PH_FRINFC_MIFARESTD_FLAG1) { 580 /* if poll flag is set then call disconnect because the authentication 581 has failed so reactivation of card is required */ 582 status = phFriNfc_MifStd_H_CallDisCon(NdefMap); 583 } 584 /* Check Authentication Flag */ 585 else if (NdefMap->StdMifareContainer.AuthDone == 586 PH_FRINFC_MIFARESTD_FLAG1) { 587 status = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) 588 ? phFriNfc_MifStd_H_RdBeforeWr(NdefMap) 589 : phFriNfc_MifStd_H_WrABlock(NdefMap)); 590 } else { 591 status = phFriNfc_MifStd_H_AuthSector(NdefMap); 592 } 593 } 594 } 595 } 596 597 return status; 598 } 599 600 /****************************************************************************** 601 * Function phFriNfc_MifareStdMap_Process 602 * 603 * Description This function is a Completion Routine, Processing function, 604 * needed to avoid long blocking. 605 * This function as a Completion Routine in order to be able 606 * to notify the component that an I/O has finished and data 607 * are ready to be processed. 608 609 * Returns void 610 * 611 ******************************************************************************/ 612 void phFriNfc_MifareStdMap_Process(void* Context, NFCSTATUS Status) { 613 phFriNfc_NdefMap_t* NdefMap; 614 uint8_t NDEFFlag = 0, CRFlag = 0, Temp16Bytes = 0, i = 0; 615 616 NdefMap = (phFriNfc_NdefMap_t*)Context; 617 618 if ((Status & PHNFCSTBLOWER) == (NFCSTATUS_SUCCESS & PHNFCSTBLOWER)) { 619 switch (NdefMap->State) { 620 case PH_FRINFC_NDEFMAP_STATE_CHK_NDEF_COMP: 621 Status = phFriNfc_MifStd_H_ProChkNdef(NdefMap); 622 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 623 ? PH_FRINFC_MIFARESTD_FLAG1 624 : PH_FRINFC_MIFARESTD_FLAG0); 625 break; 626 627 case PH_FRINFC_NDEFMAP_STATE_READ: 628 /* Receive Length for read shall always be equal to 16 */ 629 if ((*NdefMap->SendRecvLength == PH_FRINFC_MIFARESTD_BYTES_READ) && 630 (NdefMap->ApduBuffIndex < (uint16_t)NdefMap->ApduBufferSize)) { 631 Temp16Bytes = PH_FRINFC_MIFARESTD_VAL0; 632 NDEFFlag = (uint8_t)PH_FRINFC_MIFARESTD_FLAG1; 633 if (NdefMap->TLVStruct.BytesRemainLinTLV != 0) { 634 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 635 CRFlag = PH_FRINFC_MIFARESTD_FLAG0; 636 /* To read the remaining length (L) in TLV */ 637 Status = 638 phFriNfc_MifStd_H_RemainTLV(NdefMap, &NDEFFlag, &Temp16Bytes); 639 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 640 ? PH_FRINFC_MIFARESTD_FLAG1 641 : PH_FRINFC_MIFARESTD_FLAG0); 642 } 643 644 /* check the NDEFFlag is set. if this is not set, then 645 in the above RemainTLV function all the 16 bytes has been 646 read */ 647 } else { 648 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 649 NFCSTATUS_INVALID_RECEIVE_LENGTH); 650 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 651 } 652 break; 653 654 case PH_FRINFC_NDEFMAP_STATE_WRITE: 655 Status = phFriNfc_MifStd_H_ProWrABlock(NdefMap); 656 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 657 ? PH_FRINFC_MIFARESTD_FLAG1 658 : PH_FRINFC_MIFARESTD_FLAG0); 659 660 /* Call Completion Routine if CR Flag is Set to 1 */ 661 if (CRFlag == PH_FRINFC_MIFARESTD_FLAG1) { 662 *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex; 663 } 664 break; 665 666 case PH_FRINFC_NDEFMAP_STATE_AUTH: 667 NdefMap->StdMifareContainer.FirstReadFlag = PH_FRINFC_MIFARESTD_FLAG0; 668 Status = phFriNfc_MifStd_H_ProAuth(NdefMap); 669 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 670 ? PH_FRINFC_MIFARESTD_FLAG1 671 : PH_FRINFC_MIFARESTD_FLAG0); 672 break; 673 674 case PH_FRINFC_NDEFMAP_STATE_RD_ACS_BIT: 675 Status = phFriNfc_MifStd_H_ProAcsBits(NdefMap); 676 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 677 ? PH_FRINFC_MIFARESTD_FLAG1 678 : PH_FRINFC_MIFARESTD_FLAG0); 679 break; 680 681 case PH_FRINFC_NDEFMAP_STATE_WR_NDEF_LEN: 682 if (NdefMap->StdMifareContainer.RdAfterWrFlag == 683 PH_FRINFC_MIFARESTD_FLAG1) { 684 Status = phFriNfc_MifStd_H_CallWrNdefLen(NdefMap); 685 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 686 ? PH_FRINFC_MIFARESTD_FLAG1 687 : PH_FRINFC_MIFARESTD_FLAG0); 688 } else { 689 /* Check this */ 690 if (NdefMap->StdMifareContainer.TempBlockNo == 691 NdefMap->StdMifareContainer.currentBlock) { 692 memcpy(NdefMap->StdMifareContainer.internalBuf, 693 NdefMap->StdMifareContainer.Buffer, 694 NdefMap->StdMifareContainer.internalLength); 695 } 696 *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex; 697 NdefMap->StdMifareContainer.currentBlock = 698 NdefMap->StdMifareContainer.TempBlockNo; 699 NdefMap->CardState = (uint8_t)( 700 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INITIALIZED) 701 ? PH_NDEFMAP_CARD_STATE_READ_WRITE 702 : NdefMap->CardState); 703 CRFlag = (uint8_t)PH_FRINFC_MIFARESTD_FLAG1; 704 } 705 break; 706 707 case PH_FRINFC_NDEFMAP_STATE_RD_TO_WR_NDEF_LEN: 708 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 709 Status = 710 PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST); 711 if (*NdefMap->SendRecvLength == PH_FRINFC_MIFARESTD_BYTES_READ) { 712 /* Size of NdefMap->SendRecvBuf is set by phLibNfc_Gen_NdefMapReset to 713 * PH_LIBNFC_GEN_MAX_BUFFER */ 714 /* We don't have to check memory here */ 715 for (i = PH_FRINFC_MIFARESTD_BYTES_READ; i > 0; i--) { 716 NdefMap->SendRecvBuf[i] = NdefMap->SendRecvBuf[i - 1]; 717 } 718 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 719 NdefMap->StdMifareContainer.currentBlock; 720 Status = phFriNfc_MifStd_H_WriteNdefLen(NdefMap); 721 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 722 ? PH_FRINFC_MIFARESTD_FLAG1 723 : PH_FRINFC_MIFARESTD_FLAG0); 724 } 725 break; 726 727 case PH_FRINFC_NDEFMAP_STATE_GET_ACT_CARDSIZE: 728 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG1; 729 if (NdefMap->TLVStruct.NoLbytesinTLV > PH_FRINFC_MIFARESTD_VAL0) { 730 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 731 Status = phFriNfc_MifStd_H_ChkRemainTLVs(NdefMap, &CRFlag, &NDEFFlag); 732 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL0; 733 } 734 if ((NDEFFlag == PH_FRINFC_MIFARESTD_FLAG1) && 735 (CRFlag != PH_FRINFC_MIFARESTD_FLAG1)) { 736 Status = phFriNfc_MifStd_H_ChkTLVs(NdefMap, &CRFlag); 737 } 738 if (((NdefMap->StdMifareContainer.ReadNdefFlag == 739 PH_FRINFC_MIFARESTD_FLAG1) || 740 (NdefMap->StdMifareContainer.WrNdefFlag == 741 PH_FRINFC_MIFARESTD_FLAG1)) && 742 (Status != NFCSTATUS_PENDING)) { 743 NdefMap->StdMifareContainer.NFCforumSectFlag = 744 PH_FRINFC_MIFARESTD_FLAG1; 745 CRFlag = PH_FRINFC_MIFARESTD_FLAG0; 746 /* if the card state has changed to initialised and 747 read ndef is called then error is returned */ 748 if (((NdefMap->StdMifareContainer.WrNdefFlag == 749 PH_FRINFC_MIFARESTD_FLAG1) && 750 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY)) || 751 ((NdefMap->StdMifareContainer.ReadNdefFlag == 752 PH_FRINFC_MIFARESTD_FLAG1) && 753 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INITIALIZED))) { 754 Status = 755 PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT); 756 } 757 if (NdefMap->StdMifareContainer.AuthDone == 758 PH_FRINFC_MIFARESTD_FLAG0) { 759 Status = phFriNfc_MifStd_H_AuthSector(NdefMap); 760 } else { 761 Status = ((NdefMap->StdMifareContainer.ReadNdefFlag == 762 PH_FRINFC_MIFARESTD_FLAG1) 763 ? phFriNfc_MifStd_H_RdTLV(NdefMap) 764 : phFriNfc_MifStd_H_RdBeforeWr(NdefMap)); 765 } 766 NdefMap->StdMifareContainer.ReadNdefFlag = PH_FRINFC_MIFARESTD_FLAG0; 767 NdefMap->StdMifareContainer.WrNdefFlag = PH_FRINFC_MIFARESTD_FLAG0; 768 } 769 770 if (NdefMap->StdMifareContainer.ChkNdefFlag == 771 PH_FRINFC_MIFARESTD_FLAG1) { 772 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 773 ? PH_FRINFC_MIFARESTD_FLAG1 774 : PH_FRINFC_MIFARESTD_FLAG0); 775 } 776 break; 777 778 case PH_FRINFC_NDEFMAP_STATE_RD_BEF_WR: 779 /* Read flag says that already part of TLV has been written */ 780 Status = phFriNfc_MifStd_H_ProBytesToWr(NdefMap); 781 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 782 ? PH_FRINFC_MIFARESTD_FLAG1 783 : PH_FRINFC_MIFARESTD_FLAG0); 784 break; 785 786 case PH_FRINFC_NDEFMAP_STATE_WR_TLV: 787 Status = phFriNfc_MifStd_H_ProWrTLV(NdefMap); 788 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 789 ? PH_FRINFC_MIFARESTD_FLAG1 790 : PH_FRINFC_MIFARESTD_FLAG0); 791 break; 792 793 case PH_FRINFC_NDEFMAP_STATE_RD_TLV: 794 Status = phFriNfc_MifStd_H_ProRdTLV(NdefMap); 795 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 796 ? PH_FRINFC_MIFARESTD_FLAG1 797 : PH_FRINFC_MIFARESTD_FLAG0); 798 break; 799 800 case PH_FRINFC_NDEFMAP_STATE_TERM_TLV: 801 phFriNfc_MifStd_H_SetNdefBlkAuth(NdefMap); 802 NdefMap->StdMifareContainer.currentBlock = 803 NdefMap->TLVStruct.NdefTLVBlock; 804 Status = phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap); 805 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 806 ? PH_FRINFC_MIFARESTD_FLAG1 807 : PH_FRINFC_MIFARESTD_FLAG0); 808 break; 809 810 case PH_FRINFC_NDEFMAP_STATE_DISCONNECT: 811 NdefMap->StdMifareContainer.PollFlag = PH_FRINFC_MIFARESTD_FLAG0; 812 813 Status = phFriNfc_MifStd_H_CallConnect(NdefMap); 814 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 815 ? PH_FRINFC_MIFARESTD_FLAG1 816 : PH_FRINFC_MIFARESTD_FLAG0); 817 break; 818 819 case PH_FRINFC_NDEFMAP_STATE_CONNECT: 820 if (NdefMap->StdMifareContainer.FirstReadFlag == 821 PH_FRINFC_MIFARESTD_FLAG1) { 822 NdefMap->StdMifareContainer.FirstReadFlag = PH_FRINFC_MIFARESTD_FLAG0; 823 Status = phFriNfc_MifStd_H_AuthSector(NdefMap); 824 } else if ((NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD || 825 NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD || 826 NdefMap->CardType == 827 PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD) && 828 (NdefMap->StdMifareContainer.ReadOnlySectorIndex && 829 NdefMap->StdMifareContainer.SectorTrailerBlockNo == 830 NdefMap->StdMifareContainer.currentBlock)) { 831 NdefMap->StdMifareContainer.ReadOnlySectorIndex = 832 PH_FRINFC_MIFARESTD_FLAG0; 833 NdefMap->StdMifareContainer.SectorTrailerBlockNo = 834 PH_FRINFC_MIFARESTD_FLAG0; 835 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_FLAG0; 836 Status = NFCSTATUS_FAILED; 837 } else { 838 Status = 839 ((((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) && 840 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_WRITE_OPE)) || 841 (NdefMap->StdMifareContainer.WrLength > 842 PH_FRINFC_MIFARESTD_VAL0)) 843 ? phFriNfc_MifStd_H_ProStatNotValid(NdefMap, Status) 844 : phFriNfc_MifStd_H_AuthSector(NdefMap)); 845 } 846 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 847 ? PH_FRINFC_MIFARESTD_FLAG1 848 : PH_FRINFC_MIFARESTD_FLAG0); 849 break; 850 851 case PH_FRINFC_NDEFMAP_STATE_RD_SEC_ACS_BIT: 852 Status = phFriNfc_MifStd_H_ProSectorTrailorAcsBits(NdefMap); 853 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 854 ? PH_FRINFC_MIFARESTD_FLAG1 855 : PH_FRINFC_MIFARESTD_FLAG0); 856 if ((CRFlag == PH_FRINFC_MIFARESTD_FLAG1) && 857 (NdefMap->StdMifareContainer.WriteAcsBitFlag == 858 PH_FRINFC_MIFARESTD_FLAG0)) { 859 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 860 NFCSTATUS_INVALID_DEVICE_REQUEST); 861 } 862 break; 863 864 case PH_FRINFC_NDEFMAP_STATE_WRITE_SEC: 865 /* Set flag for writing of Acs bit */ 866 NdefMap->StdMifareContainer.WriteAcsBitFlag = PH_FRINFC_MIFARESTD_FLAG1; 867 868 /* The first NDEF sector is already made read only, 869 set card state to read only and proceed*/ 870 if (NdefMap->CardState != PH_NDEFMAP_CARD_STATE_READ_ONLY) { 871 Status = phFriNfc_MapTool_SetCardState( 872 NdefMap, NdefMap->TLVStruct.BytesRemainLinTLV); 873 if (Status != NFCSTATUS_SUCCESS) { 874 CRFlag = (uint8_t)PH_FRINFC_MIFARESTD_FLAG1; 875 } 876 } 877 878 if (CRFlag != PH_FRINFC_MIFARESTD_FLAG1) { 879 Status = phFriNfc_MifStd_H_ProWrSectorTrailor(NdefMap); 880 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING) 881 ? PH_FRINFC_MIFARESTD_FLAG1 882 : PH_FRINFC_MIFARESTD_FLAG0); 883 } 884 break; 885 886 default: 887 Status = 888 PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST); 889 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 890 break; 891 } 892 } else if (NdefMap->State == PH_FRINFC_NDEFMAP_STATE_AUTH) { 893 NdefMap->StdMifareContainer.PollFlag = PH_FRINFC_MIFARESTD_FLAG1; 894 if (NdefMap->StdMifareContainer.FirstWriteFlag == 895 PH_FRINFC_MIFARESTD_FLAG1) { 896 NdefMap->StdMifareContainer.FirstWriteFlag = PH_FRINFC_MIFARESTD_FLAG0; 897 NdefMap->StdMifareContainer.WrLength = 898 ((NdefMap->StdMifareContainer.NFCforumSectFlag == 899 PH_FRINFC_MIFARESTD_FLAG0) 900 ? PH_FRINFC_MIFARESTD_VAL1 901 : NdefMap->StdMifareContainer.WrLength); 902 } 903 if (NdefMap->StdMifareContainer.WrLength == PH_FRINFC_MIFARESTD_VAL0) { 904 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 905 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); 906 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 907 } else { 908 /* Authentication has failed */ 909 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; /* Call Completion Routine */ 910 Status = NFCSTATUS_FAILED; /* Update Status Flag */ 911 } 912 } else { 913 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST); 914 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 915 } 916 /* Call Completion Routine if CR Flag is Set to 1 */ 917 if (CRFlag == PH_FRINFC_MIFARESTD_FLAG1) { 918 phFriNfc_MifStd_H_Complete(NdefMap, Status); 919 } 920 921 return; 922 } 923 924 /****************************************************************************** 925 * Function phFriNfc_MifStd_H_RdABlock 926 * 927 * Description This function is a Helper function for Mifare Std. It Reads 928 * a block from the card. 929 * 930 * Returns This function return NFCSTATUS_PENDING in case of success 931 * In case of failure returns other failure value. 932 * 933 ******************************************************************************/ 934 static NFCSTATUS phFriNfc_MifStd_H_RdABlock(phFriNfc_NdefMap_t* NdefMap) { 935 NFCSTATUS status = NFCSTATUS_PENDING; 936 937 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_READ; 938 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE; 939 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 940 NdefMap->MapCompletionInfo.Context = NdefMap; 941 942 if (NdefMap->ApduBuffIndex < (uint16_t)NdefMap->ApduBufferSize) { 943 if (NdefMap->StdMifareContainer.internalLength > PH_FRINFC_MIFARESTD_VAL0) { 944 status = phFriNfc_MifStd_H_ChkIntLen(NdefMap); 945 } /* internal Length Check */ 946 else { 947 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 948 NdefMap->StdMifareContainer.currentBlock; 949 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_READ; 950 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 951 952 NdefMap->Cmd.MfCmd = phHal_eMifareRead; 953 954 /* Call the Overlapped HAL Transceive function */ 955 status = phFriNfc_ExtnsTransceive( 956 NdefMap->pTransceiveInfo, NdefMap->Cmd, NdefMap->SendRecvBuf, 957 NdefMap->SendLength, NdefMap->SendRecvLength); 958 } 959 } else { 960 /* Check for the Card Size */ 961 if ((((NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 962 NdefMap->StdMifareContainer.NdefBlocks) * 963 PH_FRINFC_MIFARESTD_BYTES_READ) == 0) || 964 (NdefMap->ApduBufferSize == NdefMap->ApduBuffIndex)) { 965 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 966 (uint8_t)((((NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 967 NdefMap->StdMifareContainer.NdefBlocks) * 968 PH_FRINFC_MIFARESTD_BYTES_READ) == 0) 969 ? PH_FRINFC_MIFARESTD_FLAG1 970 : PH_FRINFC_MIFARESTD_FLAG0); 971 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; 972 status = PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_SUCCESS); 973 } else { 974 /* Error: The control should not ideally come here. Return Error. */ 975 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_FAILED); 976 } 977 } 978 979 return status; 980 } 981 982 /****************************************************************************** 983 * Function phFriNfc_MifStd_H_WrABlock 984 * 985 * Description This function writes into a block of the card. 986 * 987 * Returns This function return NFCSTATUS_PENDING in case of success 988 * In case of failure returns other failure value. 989 * 990 ******************************************************************************/ 991 static NFCSTATUS phFriNfc_MifStd_H_WrABlock(phFriNfc_NdefMap_t* NdefMap) { 992 NFCSTATUS status = NFCSTATUS_PENDING; 993 994 uint16_t RemainingBytes = 0, BytesRemained = 0, index = 0; 995 uint8_t Temp16Bytes = 0; 996 997 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 998 NdefMap->MapCompletionInfo.Context = NdefMap; 999 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE; 1000 1001 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_WRITE; 1002 1003 /* User Buffer Check */ 1004 if (NdefMap->ApduBuffIndex < (uint16_t)NdefMap->ApduBufferSize) { 1005 RemainingBytes = 1006 (((uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) < 1007 NdefMap->StdMifareContainer.remainingSize) 1008 ? (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) 1009 : NdefMap->StdMifareContainer.remainingSize); 1010 1011 NdefMap->SendRecvBuf[0] = NdefMap->StdMifareContainer.currentBlock; 1012 Temp16Bytes += PH_FRINFC_MIFARESTD_INC_1; 1013 1014 /* Check for internal bytes */ 1015 if (NdefMap->StdMifareContainer.internalLength > 0) { 1016 /* copy the bytes previously written in the internal Buffer */ 1017 memcpy(&(NdefMap->SendRecvBuf[Temp16Bytes]), 1018 NdefMap->StdMifareContainer.internalBuf, 1019 NdefMap->StdMifareContainer.internalLength); 1020 1021 Temp16Bytes += (uint8_t)(NdefMap->StdMifareContainer.internalLength); 1022 if (RemainingBytes >= (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes)) { 1023 /* Copy the Remaining bytes from the user buffer to make the send 1024 data and length = 16 */ 1025 memcpy(&(NdefMap->SendRecvBuf[Temp16Bytes]), NdefMap->ApduBuffer, 1026 (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes)); 1027 1028 NdefMap->NumOfBytesWritten = 1029 (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes); 1030 Temp16Bytes += (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes); 1031 *NdefMap->DataCount = (Temp16Bytes - PH_FRINFC_MIFARESTD_VAL1); 1032 } else { 1033 memcpy(&(NdefMap->SendRecvBuf[Temp16Bytes]), NdefMap->ApduBuffer, 1034 RemainingBytes); 1035 1036 NdefMap->StdMifareContainer.internalBufFlag = PH_FRINFC_MIFARESTD_FLAG1; 1037 NdefMap->NumOfBytesWritten = RemainingBytes; 1038 Temp16Bytes += (uint8_t)(RemainingBytes); 1039 *NdefMap->DataCount = (Temp16Bytes - PH_FRINFC_MIFARESTD_VAL1); 1040 1041 BytesRemained = (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes); 1042 /* Pad empty bytes with Zeroes to complete 16 bytes*/ 1043 for (index = 0; index < BytesRemained; index++) { 1044 NdefMap->SendRecvBuf[(Temp16Bytes + index)] = 1045 (uint8_t)((index == PH_FRINFC_MIFARESTD_VAL0) 1046 ? PH_FRINFC_MIFARESTD_TERMTLV_T 1047 : PH_FRINFC_MIFARESTD_NULLTLV_T); 1048 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 1049 } 1050 Temp16Bytes += (uint8_t)(BytesRemained); 1051 } 1052 } else { 1053 if (RemainingBytes >= (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes)) { 1054 /* Bytes left to write < 16, copy remaining bytes */ 1055 memcpy(&(NdefMap->SendRecvBuf[Temp16Bytes]), 1056 &(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 1057 (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes)); 1058 1059 NdefMap->NumOfBytesWritten = 1060 (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes); 1061 Temp16Bytes += (MIFARE_MAX_SEND_BUF_TO_WRITE - Temp16Bytes); 1062 *NdefMap->DataCount = (Temp16Bytes - PH_FRINFC_MIFARESTD_VAL1); 1063 } else { 1064 /* Bytes left to write < 16, copy remaining bytes */ 1065 memcpy(&(NdefMap->SendRecvBuf[Temp16Bytes]), 1066 &(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), RemainingBytes); 1067 1068 NdefMap->StdMifareContainer.RemainingBufFlag = 1069 PH_FRINFC_MIFARESTD_FLAG1; 1070 NdefMap->NumOfBytesWritten = RemainingBytes; 1071 Temp16Bytes += (uint8_t)(RemainingBytes); 1072 *NdefMap->DataCount = (Temp16Bytes - PH_FRINFC_MIFARESTD_VAL1); 1073 1074 /* Pad empty bytes with Zeroes to complete 16 bytes */ 1075 for (index = Temp16Bytes; index < MIFARE_MAX_SEND_BUF_TO_WRITE; 1076 index++) { 1077 NdefMap->SendRecvBuf[index] = 1078 (uint8_t)((index == Temp16Bytes) ? PH_FRINFC_MIFARESTD_TERMTLV_T 1079 : PH_FRINFC_MIFARESTD_NULLTLV_T); 1080 1081 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 1082 } 1083 } 1084 } 1085 /* Buffer to store 16 bytes which is writing to the present block */ 1086 memcpy(NdefMap->StdMifareContainer.Buffer, 1087 &(NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_INC_1]), 1088 PH_FRINFC_MIFARESTD_BLOCK_BYTES); 1089 1090 /* Write from here */ 1091 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_WRITE; 1092 NdefMap->Cmd.MfCmd = phHal_eMifareWrite16; 1093 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 1094 /* Call the Overlapped HAL Transceive function */ 1095 status = phFriNfc_ExtnsTransceive(NdefMap->pTransceiveInfo, NdefMap->Cmd, 1096 NdefMap->SendRecvBuf, NdefMap->SendLength, 1097 NdefMap->SendRecvLength); 1098 } else /* Check User Buffer */ 1099 { 1100 if (NdefMap->StdMifareContainer.NdefBlocks > 1101 NdefMap->StdMifareContainer.NoOfNdefCompBlocks) { 1102 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 1103 PH_FRINFC_MIFARESTD_FLAG1; 1104 status = PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_SUCCESS); 1105 } else if (NdefMap->ApduBuffIndex == (uint16_t)NdefMap->ApduBufferSize) { 1106 status = PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_SUCCESS); 1107 } else { 1108 /* Error: The control should not ideally come here. Return Error. */ 1109 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_FAILED); 1110 } 1111 } 1112 1113 return status; 1114 } 1115 1116 /****************************************************************************** 1117 * Function phFriNfc_MifStd_H_AuthSector 1118 * 1119 * Description This function authenticates one sector at a time. 1120 * 1121 * Returns This function return NFCSTATUS_PENDING in case of success 1122 * In case of failure returns other failure value. 1123 * 1124 ******************************************************************************/ 1125 static NFCSTATUS phFriNfc_MifStd_H_AuthSector(phFriNfc_NdefMap_t* NdefMap) { 1126 NFCSTATUS status = NFCSTATUS_PENDING; 1127 1128 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 1129 NdefMap->MapCompletionInfo.Context = NdefMap; 1130 1131 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 1132 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_AUTH; 1133 1134 /* Authenticate */ 1135 NdefMap->Cmd.MfCmd = phHal_eMifareAuthentA; 1136 1137 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 1138 ((NdefMap->TLVStruct.NdefTLVAuthFlag == PH_FRINFC_MIFARESTD_FLAG1) 1139 ? NdefMap->TLVStruct.NdefTLVBlock 1140 : NdefMap->StdMifareContainer.currentBlock); 1141 1142 /* if MAD blocks then authentication key is 1143 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5 else 1144 0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7 */ 1145 if (((NdefMap->StdMifareContainer.currentBlock != 1146 PH_FRINFC_MIFARESTD_MAD_BLK0) && 1147 (NdefMap->StdMifareContainer.currentBlock != 1148 PH_FRINFC_MIFARESTD_MAD_BLK1) && 1149 (NdefMap->StdMifareContainer.currentBlock != 1150 PH_FRINFC_MIFARESTD_MAD_BLK2) && 1151 (NdefMap->StdMifareContainer.currentBlock != 1152 PH_FRINFC_MIFARESTD_MAD_BLK64) && 1153 (NdefMap->StdMifareContainer.currentBlock != 1154 PH_FRINFC_MIFARESTD_MAD_BLK65) && 1155 (NdefMap->StdMifareContainer.currentBlock != 1156 PH_FRINFC_MIFARESTD_MAD_BLK66)) || 1157 (NdefMap->TLVStruct.NdefTLVAuthFlag == 1158 (uint8_t)PH_FRINFC_MIFARESTD_FLAG1)) { 1159 NdefMap->SendRecvBuf[1] = 1160 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT1; /* 0xD3 */ 1161 NdefMap->SendRecvBuf[2] = 1162 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT2; /* 0xF7 */ 1163 NdefMap->SendRecvBuf[3] = 1164 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT1; /* 0xD3 */ 1165 NdefMap->SendRecvBuf[4] = 1166 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT2; /* 0xF7 */ 1167 NdefMap->SendRecvBuf[5] = 1168 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT1; /* 0xD3 */ 1169 NdefMap->SendRecvBuf[6] = 1170 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT2; /* 0xF7 */ 1171 } else { 1172 NdefMap->SendRecvBuf[1] = 1173 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT1; /* 0xA0 */ 1174 NdefMap->SendRecvBuf[2] = 1175 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT2; /* 0xA1 */ 1176 NdefMap->SendRecvBuf[3] = 1177 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT3; /* 0xA2 */ 1178 NdefMap->SendRecvBuf[4] = 1179 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT4; /* 0xA3 */ 1180 NdefMap->SendRecvBuf[5] = 1181 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT5; /* 0xA4 */ 1182 NdefMap->SendRecvBuf[6] = 1183 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_MADSECT6; /* 0xA5 */ 1184 } 1185 1186 if (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD || 1187 NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD || 1188 NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD) { 1189 if (NdefMap->StdMifareContainer.ReadOnlySectorIndex && 1190 NdefMap->StdMifareContainer.SectorTrailerBlockNo == 1191 NdefMap->StdMifareContainer.currentBlock) { 1192 memcpy(&NdefMap->SendRecvBuf[1], 1193 &NdefMap->StdMifareContainer.UserScrtKeyB[0], 1194 PH_FRINFC_MIFARESTD_KEY_LEN); 1195 1196 /* Authenticate with KeyB */ 1197 NdefMap->Cmd.MfCmd = phHal_eMifareAuthentB; 1198 } 1199 } 1200 1201 NdefMap->SendLength = MIFARE_AUTHENTICATE_CMD_LENGTH; 1202 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 1203 /* Call the Overlapped HAL Transceive function */ 1204 status = phFriNfc_ExtnsTransceive(NdefMap->pTransceiveInfo, NdefMap->Cmd, 1205 NdefMap->SendRecvBuf, NdefMap->SendLength, 1206 NdefMap->SendRecvLength); 1207 1208 return status; 1209 } 1210 1211 /****************************************************************************** 1212 * Function phFriNfc_MifStd_H_Complete 1213 * 1214 * Description It is used to call the Completion Routine 1215 * 1216 * Returns void 1217 * 1218 ******************************************************************************/ 1219 static void phFriNfc_MifStd_H_Complete(phFriNfc_NdefMap_t* NdefMap, 1220 NFCSTATUS Result) { 1221 /* set the state back to the Reset_Init state */ 1222 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RESET_INIT; 1223 1224 /* set the completion routine */ 1225 NdefMap->CompletionRoutine[NdefMap->StdMifareContainer.CRIndex] 1226 .CompletionRoutine(NdefMap->CompletionRoutine->Context, Result); 1227 1228 return; 1229 } 1230 1231 /****************************************************************************** 1232 * Function phFriNfc_MifStd4k_H_CheckNdef 1233 * 1234 * Description This function is used for Mifare 4k Check Ndef to 1235 * get the next AID blocks. 1236 * 1237 * Returns This function return NFCSTATUS_SUCCESS in case of success 1238 * In case of failure returns other failure value. 1239 * 1240 ******************************************************************************/ 1241 static NFCSTATUS phFriNfc_MifStd4k_H_CheckNdef(phFriNfc_NdefMap_t* NdefMap) { 1242 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1243 1244 /* Get the AID Block */ 1245 if (NdefMap->StdMifareContainer.currentBlock == 1246 PH_FRINFC_MIFARESTD_MAD_BLK2) { 1247 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_MAD_BLK64; 1248 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 1249 } else if (NdefMap->StdMifareContainer.currentBlock == 1250 PH_FRINFC_MIFARESTD_MAD_BLK64) { 1251 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_MAD_BLK65; 1252 } else { 1253 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_MAD_BLK66; 1254 } 1255 1256 Result = phFriNfc_MifareStdMap_ChkNdef(NdefMap); 1257 1258 return Result; 1259 } 1260 1261 /****************************************************************************** 1262 * Function phFriNfc_MifStd_H_fillAIDarray 1263 * 1264 * Description This function storew the AIDs for check ndef. 1265 * 1266 * Returns void 1267 * 1268 ******************************************************************************/ 1269 static void phFriNfc_MifStd_H_fillAIDarray(phFriNfc_NdefMap_t* NdefMap) { 1270 uint8_t byteindex = 0; 1271 1272 if ((NdefMap->StdMifareContainer.currentBlock == 1273 PH_FRINFC_MIFARESTD_MAD_BLK1) || 1274 (NdefMap->StdMifareContainer.currentBlock == 1275 PH_FRINFC_MIFARESTD_MAD_BLK64)) { 1276 /* The First Two Bytes in Receive Buffer 1277 are CRC bytes so it is not copied 1278 instead, 0 is copied in AID[0] & AID[1] */ 1279 NdefMap->StdMifareContainer.aid[NdefMap->StdMifareContainer.SectorIndex] = 1280 PH_FRINFC_MIFARESTD_NON_NDEF_COMP; 1281 NdefMap->StdMifareContainer.SectorIndex++; 1282 byteindex = 2; 1283 } 1284 1285 while (byteindex < PH_FRINFC_MIFARESTD_BYTES_READ) { 1286 if ((NdefMap->SendRecvBuf[byteindex] == 1287 PH_FRINFC_NDEFMAP_MIFARESTD_NDEF_COMPVAL2) && 1288 (NdefMap->SendRecvBuf[(byteindex + 1)] == 1289 PH_FRINFC_NDEFMAP_MIFARESTD_NDEF_COMPVAL1)) { 1290 /* This flag is set when a NFC forum sector is found in a 1291 MAD block for the first time */ 1292 NdefMap->StdMifareContainer.NFCforumSectFlag = PH_FRINFC_MIFARESTD_FLAG1; 1293 NdefMap->StdMifareContainer.aid[NdefMap->StdMifareContainer.SectorIndex] = 1294 PH_FRINFC_MIFARESTD_NDEF_COMP; 1295 NdefMap->StdMifareContainer.SectorIndex++; 1296 } else { 1297 NdefMap->StdMifareContainer.aid[NdefMap->StdMifareContainer.SectorIndex] = 1298 PH_FRINFC_MIFARESTD_NON_NDEF_COMP; 1299 NdefMap->StdMifareContainer.SectorIndex++; 1300 /* AID complete flag is set when a non NFC forum sector is found in a 1301 MAD block after the NFC forum sector. After setting this, all other 1302 values are ignored and are NOT NDEF compliant */ 1303 NdefMap->StdMifareContainer.aidCompleteFlag = 1304 ((NdefMap->StdMifareContainer.NFCforumSectFlag == 1305 PH_FRINFC_MIFARESTD_FLAG1) 1306 ? PH_FRINFC_MIFARESTD_FLAG1 1307 : PH_FRINFC_MIFARESTD_FLAG0); 1308 1309 NdefMap->StdMifareContainer.NFCforumSectFlag = PH_FRINFC_MIFARESTD_FLAG0; 1310 if (NdefMap->StdMifareContainer.aidCompleteFlag == 1311 PH_FRINFC_MIFARESTD_FLAG1) { 1312 break; 1313 } 1314 } 1315 byteindex += 2; 1316 } 1317 1318 /* If "aidCompleteFlag" is set then the remaining sectors are made NOT 1319 NDEF compliant */ 1320 if ((NdefMap->StdMifareContainer.aidCompleteFlag == 1321 PH_FRINFC_MIFARESTD_FLAG1) && 1322 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD)) { 1323 /* for Mifare 1k there are 16 sectors, till this number all sectors 1324 are made NOT NDEF compliant */ 1325 for (byteindex = NdefMap->StdMifareContainer.SectorIndex; 1326 byteindex < PH_FRINFC_MIFARESTD1K_TOTAL_SECTOR; byteindex++) { 1327 NdefMap->StdMifareContainer.aid[byteindex] = 1328 PH_FRINFC_MIFARESTD_NON_NDEF_COMP; 1329 } 1330 } else if ((NdefMap->StdMifareContainer.aidCompleteFlag == 1331 PH_FRINFC_MIFARESTD_FLAG1) && 1332 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD)) { 1333 /* for Mifare 2k there are 32 sectors, till this number all sectors 1334 are made NOT NDEF compliant */ 1335 for (byteindex = NdefMap->StdMifareContainer.SectorIndex; 1336 byteindex < PH_FRINFC_MIFARESTD2K_TOTAL_SECTOR; byteindex++) { 1337 NdefMap->StdMifareContainer.aid[byteindex] = 1338 PH_FRINFC_MIFARESTD_NON_NDEF_COMP; 1339 } 1340 } else { 1341 /* for Mifare 4k there are 40 sectors, till this number all sectors 1342 are made NOT NDEF compliant */ 1343 if ((NdefMap->StdMifareContainer.aidCompleteFlag == 1344 PH_FRINFC_MIFARESTD_FLAG1) && 1345 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD)) { 1346 for (byteindex = NdefMap->StdMifareContainer.SectorIndex; 1347 byteindex < PH_FRINFC_MIFARESTD4K_TOTAL_SECTOR; byteindex++) { 1348 NdefMap->StdMifareContainer.aid[byteindex] = 1349 PH_FRINFC_MIFARESTD_NON_NDEF_COMP; 1350 } 1351 } 1352 } 1353 1354 return; 1355 } 1356 1357 /****************************************************************************** 1358 * Function phFriNfc_MifStd_H_BlkChk 1359 * 1360 * Description This function is to check the Ndef compliance of the 1361 * current block, if the block is not Ndef Compliant, 1362 * increment the block till the next Ndef compliant block 1363 * using the Get Sector Helper function 1364 * 1365 * Returns This function return NFCSTATUS_SUCCESS in case of success 1366 * In case of failure returns other failure value. 1367 * 1368 ******************************************************************************/ 1369 static NFCSTATUS phFriNfc_MifStd_H_BlkChk(phFriNfc_NdefMap_t* NdefMap) { 1370 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1371 uint8_t SectorID = 0, callbreak = 0; 1372 1373 for (;;) { 1374 /* Get a Sector ID for the Current Block */ 1375 SectorID = 1376 phFriNfc_MifStd_H_GetSect(NdefMap->StdMifareContainer.currentBlock); 1377 /* Check the card Type 1k or 4k */ 1378 /* enter if Mifare 1k card. For Mifare 4k go to else */ 1379 if (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD) { 1380 /* if Sector Id > 15 No Sectors to write */ 1381 if (SectorID > 15) { 1382 SectorID = 1383 phFriNfc_MifStd_H_GetSect(NdefMap->StdMifareContainer.currentBlock); 1384 /*Error: No Ndef Compliant Sectors present */ 1385 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 1386 callbreak = 1; 1387 } else { 1388 phFriNfc_MifStd1k_H_BlkChk(NdefMap, SectorID, &callbreak); 1389 } 1390 } /* End of if */ /* End of Mifare 1k check */ 1391 else if (NdefMap->CardType == 1392 PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD) /* Mifare 2k check starts 1393 here */ 1394 { 1395 /* Sector > 39 no ndef compliant sectors found*/ 1396 if (SectorID > PH_FRINFC_MIFARESTD_SECTOR_NO31) { 1397 /*Error: No Ndef Compliant Sectors present */ 1398 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 1399 callbreak = 1; 1400 } else if (NdefMap->StdMifareContainer.currentBlock == 1401 PH_FRINFC_MIFARESTD_MAD_BLK64) { 1402 NdefMap->StdMifareContainer.currentBlock += PH_FRINFC_MIFARESTD_BLK4; 1403 } else if (SectorID < PH_FRINFC_MIFARESTD_SECTOR_NO32) /* sector < 32 1404 contains 4 1405 blocks in each 1406 sector */ 1407 { 1408 /* If the block checked is 63, the 3 blocks after this 1409 are AID(MAD) blocks so its need to be skipped */ 1410 if (NdefMap->StdMifareContainer.currentBlock == 1411 PH_FRINFC_MIFARESTD_MAD_BLK63) { 1412 NdefMap->StdMifareContainer.currentBlock += PH_FRINFC_MIFARESTD_BLK4; 1413 } else { 1414 phFriNfc_MifStd1k_H_BlkChk(NdefMap, SectorID, &callbreak); 1415 } 1416 } else { 1417 phFriNfc_MifStd1k_H_BlkChk(NdefMap, SectorID, &callbreak); 1418 } 1419 } /* End of if*/ /* End of Mifare 2k check*/ 1420 else /* Mifare 4k check starts here */ 1421 { 1422 /* Sector > 39 no ndef compliant sectors found*/ 1423 if (SectorID > PH_FRINFC_MIFARESTD_SECTOR_NO39) { 1424 /*Error: No Ndef Compliant Sectors present */ 1425 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 1426 callbreak = 1; 1427 } else if (NdefMap->StdMifareContainer.currentBlock == 1428 PH_FRINFC_MIFARESTD_MAD_BLK64) { 1429 NdefMap->StdMifareContainer.currentBlock += PH_FRINFC_MIFARESTD_BLK4; 1430 } else if (SectorID < PH_FRINFC_MIFARESTD_SECTOR_NO32) /* sector < 32 1431 contains 4 1432 blocks in each 1433 sector */ 1434 { 1435 /* If the block checked is 63, the 3 blocks after this 1436 are AID(MAD) blocks so its need to be skipped */ 1437 if (NdefMap->StdMifareContainer.currentBlock == 1438 PH_FRINFC_MIFARESTD_MAD_BLK63) { 1439 NdefMap->StdMifareContainer.currentBlock += PH_FRINFC_MIFARESTD_BLK4; 1440 } else { 1441 phFriNfc_MifStd1k_H_BlkChk(NdefMap, SectorID, &callbreak); 1442 } 1443 } else { 1444 /* every last block of a sector needs to be skipped */ 1445 if (((NdefMap->StdMifareContainer.currentBlock + 1) % 1446 PH_FRINFC_MIFARESTD_BLOCK_BYTES) == 0) { 1447 NdefMap->StdMifareContainer.currentBlock++; 1448 } else { 1449 if (NdefMap->StdMifareContainer.aid[SectorID] == 1450 PH_FRINFC_MIFARESTD_NDEF_COMP) { 1451 /* Check whether the block is first block of a (next)new sector and 1452 also check if it is first block then internal length is zero 1453 or not. Because once Authentication is done for the sector again 1454 we should not authenticate it again */ 1455 /* In this case 32 sectors contains 4 blocks and next remaining 8 1456 sectors contains 16 blocks that is why (32 * 4) + (sectorID - 32) 1457 *16*/ 1458 if ((NdefMap->StdMifareContainer.currentBlock == 1459 ((PH_FRINFC_MIFARESTD_SECTOR_NO32 * PH_FRINFC_MIFARESTD_BLK4) + 1460 ((SectorID - PH_FRINFC_MIFARESTD_SECTOR_NO32) * 1461 PH_FRINFC_MIFARESTD_BLOCK_BYTES))) && 1462 (NdefMap->StdMifareContainer.internalLength == 0)) { 1463 NdefMap->StdMifareContainer.AuthDone = 0; 1464 } 1465 callbreak = 1; 1466 } else { 1467 NdefMap->StdMifareContainer.currentBlock += 16; 1468 } 1469 } 1470 } 1471 } 1472 if (callbreak == 1) { 1473 break; 1474 } 1475 } 1476 1477 return Result; 1478 } 1479 1480 /****************************************************************************** 1481 * Function phFriNfc_MifStd_H_GetSect 1482 * 1483 * Description This function to get the Sector from the current block 1484 * 1485 * Returns uint8_t SectorID 1486 * 1487 ******************************************************************************/ 1488 static uint8_t phFriNfc_MifStd_H_GetSect(uint8_t BlockNumber) { 1489 uint8_t SectorID = 0; 1490 1491 if (BlockNumber >= PH_FRINFC_MIFARESTD4K_BLK128) { 1492 SectorID = (uint8_t)(PH_FRINFC_MIFARESTD_SECTOR_NO32 + 1493 ((BlockNumber - PH_FRINFC_MIFARESTD4K_BLK128) / 1494 PH_FRINFC_MIFARESTD_BLOCK_BYTES)); 1495 } else { 1496 SectorID = (BlockNumber / PH_FRINFC_MIFARESTD_BLK4); 1497 } 1498 1499 return SectorID; 1500 } 1501 1502 /****************************************************************************** 1503 * Function phFriNfc_MifStd_H_RdAcsBit 1504 * 1505 * Description It read the access bits of each sector. 1506 * NCI messages. 1507 * 1508 * Returns This function return NFCSTATUS_SUCCESS in case of success 1509 * In case of failure returns other failure value. 1510 * 1511 ******************************************************************************/ 1512 static NFCSTATUS phFriNfc_MifStd_H_RdAcsBit(phFriNfc_NdefMap_t* NdefMap) { 1513 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1514 1515 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RD_ACS_BIT; 1516 1517 if (NdefMap->StdMifareContainer.ReadOnlySectorIndex && 1518 NdefMap->StdMifareContainer.currentBlock == 1519 NdefMap->StdMifareContainer.SectorTrailerBlockNo) { 1520 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RD_SEC_ACS_BIT; 1521 } 1522 1523 if (NdefMap->StdMifareContainer.ReadAcsBitFlag == PH_FRINFC_MIFARESTD_FLAG1) { 1524 /* Get the sector trailer */ 1525 ((NdefMap->StdMifareContainer.currentBlock > 127) 1526 ? phFriNfc_MifStd_H_Get4kStTrail(NdefMap) 1527 : phFriNfc_MifStd_H_Get1kStTrail(NdefMap)); 1528 } else { 1529 /* Give the current block to read */ 1530 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 1531 NdefMap->StdMifareContainer.currentBlock; 1532 } 1533 1534 Result = phFriNfc_MifStd_H_Rd16Bytes( 1535 NdefMap, NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0]); 1536 1537 return Result; 1538 } 1539 1540 /****************************************************************************** 1541 * Function phFriNfc_MifStd_H_ChkAcsBit 1542 * 1543 * Description This function check the access bits of each sector. 1544 * 1545 * Returns This function return NFCSTATUS_SUCCESS in case of success 1546 * In case of failure returns other failure value. 1547 * 1548 ******************************************************************************/ 1549 static NFCSTATUS phFriNfc_MifStd_H_ChkAcsBit(phFriNfc_NdefMap_t* NdefMap) { 1550 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1551 1552 /* Blocks from 0 to 3 and from 64 to 67(MAD blocks) */ 1553 if ((NdefMap->StdMifareContainer.currentBlock == 1554 PH_FRINFC_MIFARESTD_MAD_BLK0) || 1555 (NdefMap->StdMifareContainer.currentBlock == 1556 PH_FRINFC_MIFARESTD_MAD_BLK1) || 1557 (NdefMap->StdMifareContainer.currentBlock == 1558 PH_FRINFC_MIFARESTD_MAD_BLK2) || 1559 (NdefMap->StdMifareContainer.currentBlock == 1560 PH_FRINFC_MIFARESTD_MAD_BLK3) || 1561 (NdefMap->StdMifareContainer.currentBlock == 1562 PH_FRINFC_MIFARESTD_MAD_BLK64) || 1563 (NdefMap->StdMifareContainer.currentBlock == 1564 PH_FRINFC_MIFARESTD_MAD_BLK65) || 1565 (NdefMap->StdMifareContainer.currentBlock == 1566 PH_FRINFC_MIFARESTD_MAD_BLK66)) { 1567 /* Access bits check removed for the MAD blocks */ 1568 #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD 1569 1570 if (((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL6] & 1571 PH_FRINFC_MIFARESTD_MASK_FF) == 1572 PH_FRINFC_MIFARESTD_MADSECT_ACS_BYTE6) && 1573 ((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL7] & 1574 PH_FRINFC_MIFARESTD_MASK_FF) == 1575 PH_FRINFC_MIFARESTD_MADSECT_ACS_BYTE7) && 1576 ((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL8] & 1577 PH_FRINFC_MIFARESTD_MASK_FF) == PH_FRINFC_MIFARESTD_ACS_BYTE8)) { 1578 NdefMap->StdMifareContainer.WriteFlag = PH_FRINFC_MIFARESTD_FLAG0; 1579 NdefMap->StdMifareContainer.ReadFlag = PH_FRINFC_MIFARESTD_FLAG1; 1580 } else { 1581 NdefMap->StdMifareContainer.WriteFlag = PH_FRINFC_MIFARESTD_FLAG0; 1582 NdefMap->StdMifareContainer.ReadFlag = PH_FRINFC_MIFARESTD_FLAG0; 1583 } 1584 1585 #else /* #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD */ 1586 1587 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED; 1588 1589 #endif /* #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD */ 1590 } else { 1591 /* Check for Access bytes 6, 7 and 8 value = 1592 0x7F, 0x07, 0x88 NFC forum sectors*/ 1593 if (((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL6] & 1594 PH_FRINFC_MIFARESTD_MASK_FF) == 1595 PH_FRINFC_MIFARESTD_NFCSECT_ACS_BYTE6) && 1596 ((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL7] & 1597 PH_FRINFC_MIFARESTD_MASK_FF) == 1598 PH_FRINFC_MIFARESTD_NFCSECT_ACS_BYTE7) && 1599 ((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL8] & 1600 PH_FRINFC_MIFARESTD_MASK_FF) == PH_FRINFC_MIFARESTD_ACS_BYTE8)) { 1601 NdefMap->StdMifareContainer.WriteFlag = PH_FRINFC_MIFARESTD_FLAG1; 1602 NdefMap->StdMifareContainer.ReadFlag = PH_FRINFC_MIFARESTD_FLAG1; 1603 } else if (((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL6] & 1604 PH_FRINFC_MIFARESTD_MASK_FF) == 1605 PH_FRINFC_MIFARESTD_NFCSECT_RDACS_BYTE6) && 1606 ((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL7] & 1607 PH_FRINFC_MIFARESTD_MASK_FF) == 1608 PH_FRINFC_MIFARESTD_NFCSECT_RDACS_BYTE7) && 1609 ((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL8] & 1610 PH_FRINFC_MIFARESTD_MASK_FF) == 1611 PH_FRINFC_MIFARESTD_NFCSECT_RDACS_BYTE8)) { 1612 /* Read Only state */ 1613 /* Check for Access bytes 6, 7 and 8 value = 1614 0x55, 0xAD, 0x2A NFC forum Sectors */ 1615 NdefMap->StdMifareContainer.WriteFlag = PH_FRINFC_MIFARESTD_FLAG0; 1616 NdefMap->StdMifareContainer.ReadFlag = PH_FRINFC_MIFARESTD_FLAG1; 1617 } else { 1618 NdefMap->StdMifareContainer.WriteFlag = PH_FRINFC_MIFARESTD_FLAG0; 1619 NdefMap->StdMifareContainer.ReadFlag = PH_FRINFC_MIFARESTD_FLAG0; 1620 } 1621 1622 #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD 1623 /* Do nothing */ 1624 #else /* #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD */ 1625 Result = phFriNfc_MifStd_H_GPBChk(NdefMap); 1626 #endif /* #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD */ 1627 } 1628 1629 #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD 1630 Result = phFriNfc_MifStd_H_GPBChk(NdefMap); 1631 #endif /* #ifdef ENABLE_ACS_BIT_CHK_FOR_MAD */ 1632 1633 return Result; 1634 } 1635 1636 /****************************************************************************** 1637 * Function phFriNfc_MifStd_H_ChkRdWr 1638 * 1639 * Description This function is for read access bits, depending 1640 * on the read/write/check ndef function called. 1641 * 1642 * Returns This function return NFCSTATUS_SUCCESS in case of success 1643 * In case of failure returns other failure value. 1644 * 1645 ******************************************************************************/ 1646 static NFCSTATUS phFriNfc_MifStd_H_ChkRdWr(phFriNfc_NdefMap_t* NdefMap) { 1647 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1648 1649 switch (NdefMap->PrevOperation) { 1650 case PH_FRINFC_NDEFMAP_CHECK_OPE: 1651 if (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) { 1652 /* No permission to read */ 1653 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_READ_FAILED); 1654 } else if ((NdefMap->StdMifareContainer.currentBlock > 3) && 1655 (NdefMap->StdMifareContainer.ChkNdefCompleteFlag == 1656 PH_FRINFC_MIFARESTD_FLAG1) && 1657 (NdefMap->StdMifareContainer.currentBlock != 1658 PH_FRINFC_MIFARESTD_MAD_BLK65) && 1659 (NdefMap->StdMifareContainer.currentBlock != 1660 PH_FRINFC_MIFARESTD_MAD_BLK66)) { 1661 Result = ((NdefMap->StdMifareContainer.ReadAcsBitFlag == 1662 PH_FRINFC_MIFARESTD_FLAG0) 1663 ? phFriNfc_MifStd_H_RdAcsBit(NdefMap) 1664 : phFriNfc_MifStd_H_AuthSector(NdefMap)); 1665 } else { 1666 Result = phFriNfc_MifareStdMap_ChkNdef(NdefMap); 1667 } 1668 break; 1669 1670 case PH_FRINFC_NDEFMAP_READ_OPE: 1671 if (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) { 1672 /* No permission to Read */ 1673 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_READ_FAILED); 1674 } else if (NdefMap->StdMifareContainer.ReadNdefFlag == 1675 PH_FRINFC_MIFARESTD_FLAG1) { 1676 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 1677 } else { 1678 Result = phFriNfc_MifStd_H_RdABlock(NdefMap); 1679 } 1680 break; 1681 1682 case PH_FRINFC_NDEFMAP_WRITE_OPE: 1683 if ((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) || 1684 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY)) { 1685 /* No permission to Read */ 1686 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_WRITE_FAILED); 1687 } else if (NdefMap->StdMifareContainer.WrNdefFlag == 1688 PH_FRINFC_MIFARESTD_FLAG1) { 1689 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 1690 } else if (NdefMap->StdMifareContainer.RdBeforeWrFlag == 1691 PH_FRINFC_MIFARESTD_FLAG1) { 1692 /*NdefMap->StdMifareContainer.ReadFlag = 1693 PH_FRINFC_MIFARESTD_FLAG0;*/ 1694 Result = phFriNfc_MifStd_H_RdBeforeWr(NdefMap); 1695 } else if (NdefMap->StdMifareContainer.RdAfterWrFlag == 1696 PH_FRINFC_MIFARESTD_FLAG1) { 1697 Result = phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap); 1698 } else { 1699 Result = (((NdefMap->TLVStruct.NdefTLVBlock == 1700 NdefMap->StdMifareContainer.currentBlock) && 1701 (NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)) 1702 ? phFriNfc_MifStd_H_RdBeforeWr(NdefMap) 1703 : phFriNfc_MifStd_H_WrABlock(NdefMap)); 1704 } 1705 break; 1706 1707 case PH_FRINFC_NDEFMAP_GET_ACTSIZE_OPE: 1708 Result = 1709 ((NdefMap->StdMifareContainer.ReadFlag == PH_FRINFC_MIFARESTD_FLAG0) 1710 ? (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_READ_FAILED)) 1711 : phFriNfc_MifStd_H_GetActCardLen(NdefMap)); 1712 break; 1713 1714 default: 1715 /* Operation is not correct */ 1716 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 1717 1718 break; 1719 } 1720 1721 return Result; 1722 } 1723 1724 /****************************************************************************** 1725 * Function phFriNfc_MifStd_H_ChkNdefCmpltSects 1726 * 1727 * Description This function is used to check ndef to check the 1728 * ndef compliant sectors. 1729 * 1730 * Returns void 1731 * 1732 ******************************************************************************/ 1733 static void phFriNfc_MifStd_H_ChkNdefCmpltSects(phFriNfc_NdefMap_t* NdefMap) { 1734 uint8_t index = 0; 1735 uint8_t index_max_4k_2k = 0; 1736 if (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD) { 1737 index_max_4k_2k = PH_FRINFC_MIFARESTD4K_TOTAL_SECTOR; 1738 } else { 1739 index_max_4k_2k = PH_FRINFC_MIFARESTD2K_TOTAL_SECTOR; 1740 } 1741 1742 if (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD || 1743 NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD) { 1744 for (index = PH_FRINFC_MIFARESTD_SECTOR_NO1; index < index_max_4k_2k; 1745 index++) /*Block 0 is MAD block, so it should start with 1*/ 1746 { 1747 /* For Mifare 4k, Block 0 to 31 contains 4 blocks */ 1748 /* sector 0 and 15 are aid blocks */ 1749 if (index != PH_FRINFC_MIFARESTD_SECTOR_NO16) { 1750 if (((index < 32) && (index != PH_FRINFC_MIFARESTD_SECTOR_NO0)) && 1751 (NdefMap->StdMifareContainer.aid[index] == 1752 PH_FRINFC_MIFARESTD_NON_NDEF_COMP)) { 1753 /* Only 3 blocks can be read/written till sector 31 */ 1754 NdefMap->StdMifareContainer.NoOfNdefCompBlocks -= 1755 PH_FRINFC_MIFARESTD_MAD_BLK3; 1756 1757 } else { 1758 /* For Mifare 4k, Block 32 to 39 contains 16 blocks */ 1759 if (NdefMap->StdMifareContainer.aid[index] == 1760 PH_FRINFC_MIFARESTD_NON_NDEF_COMP) { 1761 /* Only 15 blocks can be read/written from sector 31 */ 1762 NdefMap->StdMifareContainer.NoOfNdefCompBlocks -= 1763 PH_FRINFC_MIFARESTD_BLK15; 1764 } 1765 } 1766 } 1767 } /* For index > 40 */ 1768 } else { 1769 for (index = PH_FRINFC_MIFARESTD_SECTOR_NO1; 1770 index < PH_FRINFC_MIFARESTD_SECTOR_NO16; index++) { 1771 if (NdefMap->StdMifareContainer.aid[index] == 1772 PH_FRINFC_MIFARESTD_NON_NDEF_COMP) { 1773 /* Only three blocks can be read/written in 1774 a sector. So if a sector is non-ndef 1775 compliant, decrement 3 */ 1776 NdefMap->StdMifareContainer.NoOfNdefCompBlocks -= 1777 PH_FRINFC_MIFARESTD_MAD_BLK3; 1778 } 1779 } 1780 } 1781 1782 return; 1783 } 1784 1785 /****************************************************************************** 1786 * Function phFriNfc_MifStd_H_RemainTLV 1787 * 1788 * Description This function is used for read ndef to process the 1789 * remaining bytes of length (L) in the TLV. 1790 * 1791 * Returns This function return NFCSTATUS_PENDING in case of success 1792 * In case of failure returns other failure value. 1793 * 1794 ******************************************************************************/ 1795 static NFCSTATUS phFriNfc_MifStd_H_RemainTLV(phFriNfc_NdefMap_t* NdefMap, 1796 uint8_t* Flag, 1797 uint8_t* Temp16Bytes) { 1798 NFCSTATUS Result = NFCSTATUS_SUCCESS; 1799 uint8_t CRFlag = 0; 1800 uint16_t RemainingBytes = 0; 1801 1802 RemainingBytes = ((uint16_t)NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); 1803 1804 if (NdefMap->StdMifareContainer.remainingSize < RemainingBytes) { 1805 /* If the user Buffer is greater than the Card Size 1806 set LastBlockFlag = 1. This Flag is used to read bytes 1807 till the end of the card only */ 1808 RemainingBytes = NdefMap->StdMifareContainer.remainingSize; 1809 } 1810 1811 /* Remaining Bytes of length (L) in TLV <= 16 */ 1812 if ((NdefMap->TLVStruct.BytesRemainLinTLV <= 1813 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes))) && 1814 (RemainingBytes <= NdefMap->TLVStruct.BytesRemainLinTLV)) { 1815 /* Copy data to user buffer */ 1816 memcpy(&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 1817 &(NdefMap->SendRecvBuf[(*Temp16Bytes)]), RemainingBytes); 1818 1819 NdefMap->ApduBuffIndex += RemainingBytes; 1820 NdefMap->StdMifareContainer.remainingSize -= RemainingBytes; 1821 1822 /* copy the bytes to internal buffer, that are read, 1823 but not used for the user buffer */ 1824 if (RemainingBytes != NdefMap->TLVStruct.BytesRemainLinTLV) { 1825 memcpy( 1826 NdefMap->StdMifareContainer.internalBuf, 1827 &(NdefMap->SendRecvBuf[((*Temp16Bytes) + RemainingBytes)]), 1828 ((PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)) - RemainingBytes)); 1829 1830 /* internal buffer length */ 1831 NdefMap->StdMifareContainer.internalLength = 1832 ((PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)) - RemainingBytes); 1833 } 1834 *Temp16Bytes += ((uint8_t)RemainingBytes); 1835 /* Remaining Bytes of length value in TLV */ 1836 NdefMap->TLVStruct.BytesRemainLinTLV -= RemainingBytes; 1837 1838 if (NdefMap->StdMifareContainer.internalLength == 1839 PH_FRINFC_MIFARESTD_VAL0) { 1840 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t)( 1841 ((NdefMap->StdMifareContainer.remainingSize == 1842 PH_FRINFC_MIFARESTD_VAL0) || 1843 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0)) 1844 ? PH_FRINFC_MIFARESTD_FLAG1 1845 : PH_FRINFC_MIFARESTD_FLAG0); 1846 1847 /* internal length bytes completed */ 1848 NdefMap->StdMifareContainer.currentBlock++; 1849 NdefMap->StdMifareContainer.NdefBlocks++; 1850 } 1851 1852 if (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0) { 1853 /* Remaining Bytes of length (L) in TLV is Zero means that the next 1854 coming bytes are containing type (T), length (L) in TLV */ 1855 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 1856 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 1857 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 1858 } 1859 /* call completion routine */ 1860 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 1861 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 1862 } else if ((NdefMap->TLVStruct.BytesRemainLinTLV <= 1863 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes))) && 1864 (RemainingBytes > NdefMap->TLVStruct.BytesRemainLinTLV)) { 1865 /* Copy data to user buffer */ 1866 memcpy(&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 1867 &(NdefMap->SendRecvBuf[(*Temp16Bytes)]), 1868 NdefMap->TLVStruct.BytesRemainLinTLV); 1869 1870 NdefMap->ApduBuffIndex += NdefMap->TLVStruct.BytesRemainLinTLV; 1871 NdefMap->StdMifareContainer.remainingSize -= 1872 NdefMap->TLVStruct.BytesRemainLinTLV; 1873 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 1874 *Temp16Bytes += ((uint8_t)NdefMap->TLVStruct.BytesRemainLinTLV); 1875 NdefMap->TLVStruct.BytesRemainLinTLV = PH_FRINFC_MIFARESTD_VAL0; 1876 1877 *Flag = PH_FRINFC_MIFARESTD_FLAG1; 1878 1879 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 1880 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 1881 /* 16 bytes completed */ 1882 if (NdefMap->TLVStruct.BytesRemainLinTLV == 1883 PH_FRINFC_MIFARESTD_BYTES_READ) { 1884 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 1885 NdefMap->TLVStruct.BytesRemainLinTLV = 1886 PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0; 1887 NdefMap->StdMifareContainer.currentBlock++; 1888 NdefMap->StdMifareContainer.NdefBlocks++; 1889 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 1890 if (Result == NFCSTATUS_SUCCESS) { 1891 if (NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1) { 1892 Result = phFriNfc_MifStd_H_RdABlock(NdefMap); 1893 } else { 1894 Result = phFriNfc_MifStd_H_AuthSector(NdefMap); 1895 } 1896 } 1897 } else { 1898 NdefMap->TLVStruct.BytesRemainLinTLV = 1899 PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0; 1900 /* The read operation has finished. so, completion routine 1901 can be called. set the Completion routine(CR) flag */ 1902 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 1903 } 1904 } else if ((NdefMap->TLVStruct.BytesRemainLinTLV > 1905 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes))) && 1906 (RemainingBytes <= 1907 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)))) { 1908 /* Copy data to user buffer */ 1909 memcpy(&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 1910 &(NdefMap->SendRecvBuf[(*Temp16Bytes)]), RemainingBytes); 1911 NdefMap->ApduBuffIndex += RemainingBytes; 1912 NdefMap->StdMifareContainer.remainingSize -= RemainingBytes; 1913 1914 /* Remaining Bytes of length (L) in TLV */ 1915 NdefMap->TLVStruct.BytesRemainLinTLV -= RemainingBytes; 1916 /* copy the bytes to internal buffer, that are read, 1917 but not used for the user buffer */ 1918 memcpy( 1919 NdefMap->StdMifareContainer.internalBuf, 1920 &(NdefMap->SendRecvBuf[(RemainingBytes + (*Temp16Bytes))]), 1921 ((PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)) - RemainingBytes)); 1922 1923 /* internal buffer length */ 1924 NdefMap->StdMifareContainer.internalLength = 1925 ((PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)) - RemainingBytes); 1926 1927 if (RemainingBytes == (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes))) { 1928 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t)( 1929 ((NdefMap->StdMifareContainer.remainingSize == 1930 PH_FRINFC_MIFARESTD_VAL0) || 1931 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0)) 1932 ? PH_FRINFC_MIFARESTD_FLAG1 1933 : PH_FRINFC_MIFARESTD_FLAG0); 1934 1935 /* internal length bytes completed */ 1936 NdefMap->StdMifareContainer.currentBlock++; 1937 NdefMap->StdMifareContainer.NdefBlocks++; 1938 } 1939 *Temp16Bytes += ((uint8_t)RemainingBytes); 1940 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 1941 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 1942 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 1943 } else { 1944 if ((NdefMap->TLVStruct.BytesRemainLinTLV > 1945 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes))) && 1946 (RemainingBytes > (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)))) { 1947 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 1948 /* Copy data to user buffer */ 1949 memcpy(&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 1950 &(NdefMap->SendRecvBuf[(*Temp16Bytes)]), 1951 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes))); 1952 NdefMap->ApduBuffIndex += 1953 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)); 1954 NdefMap->StdMifareContainer.remainingSize -= 1955 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)); 1956 NdefMap->TLVStruct.BytesRemainLinTLV -= 1957 (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)); 1958 *Temp16Bytes += (PH_FRINFC_MIFARESTD_BYTES_READ - (*Temp16Bytes)); 1959 if (NdefMap->TLVStruct.BytesRemainLinTLV != 1960 PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0) { 1961 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 1962 } 1963 /* 16 bytes completed */ 1964 NdefMap->StdMifareContainer.currentBlock++; 1965 NdefMap->StdMifareContainer.NdefBlocks++; 1966 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 1967 if (Result == NFCSTATUS_SUCCESS) { 1968 Result = 1969 ((NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1) 1970 ? phFriNfc_MifStd_H_RdABlock(NdefMap) 1971 : phFriNfc_MifStd_H_AuthSector(NdefMap)); 1972 } 1973 } 1974 } 1975 1976 if (CRFlag == PH_FRINFC_MIFARESTD_FLAG1) { 1977 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; 1978 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t)( 1979 ((NdefMap->StdMifareContainer.remainingSize == 1980 PH_FRINFC_MIFARESTD_VAL0) || 1981 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0)) 1982 ? PH_FRINFC_MIFARESTD_FLAG1 1983 : PH_FRINFC_MIFARESTD_FLAG0); 1984 } 1985 1986 return Result; 1987 } 1988 1989 /****************************************************************************** 1990 * Function phFriNfc_MifStd_H_ChkIntLen 1991 * 1992 * Description This function reads ndef to process the internal bytes. 1993 * 1994 * Returns This function return NFCSTATUS_SUCCESS in case of success, 1995 * In case of failure returns other failure value. 1996 * 1997 ******************************************************************************/ 1998 static NFCSTATUS phFriNfc_MifStd_H_ChkIntLen(phFriNfc_NdefMap_t* NdefMap) { 1999 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2000 uint8_t NDEFFlag = PH_FRINFC_MIFARESTD_FLAG1; 2001 uint8_t TempintBytes = 0; 2002 2003 if (NdefMap->TLVStruct.BytesRemainLinTLV != 0) { 2004 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 2005 /* To read the remaining length (L) in TLV */ 2006 Result = 2007 phFriNfc_MifStd_H_IntLenWioutNdef(NdefMap, &NDEFFlag, &TempintBytes); 2008 } 2009 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 2010 /* check the NDEFFlag is set. if this is not set, then 2011 in the above RemainTLV function all the 16 bytes has been 2012 read */ 2013 2014 return Result; 2015 } 2016 2017 /****************************************************************************** 2018 * Function phFriNfc_MifStd_H_IntLenWioutNdef 2019 * 2020 * Description This function reads ndef to check the internal bytes 2021 * without ndef tlv flag. 2022 * 2023 * Returns This function return NFCSTATUS_SUCCESS in case of success, 2024 * In case of failure returns other failure value. 2025 * 2026 ******************************************************************************/ 2027 static NFCSTATUS phFriNfc_MifStd_H_IntLenWioutNdef(phFriNfc_NdefMap_t* NdefMap, 2028 uint8_t* Flag, 2029 uint8_t* TempintBytes) { 2030 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2031 uint8_t CRFlag = 0; 2032 uint16_t RemainingBytes = 0; 2033 2034 RemainingBytes = ((uint16_t)NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); 2035 2036 if (NdefMap->StdMifareContainer.remainingSize < RemainingBytes) { 2037 /* If the user Buffer is greater than the Card Size 2038 set LastBlockFlag = 1. This Flag is used to read bytes 2039 till the end of the card only */ 2040 RemainingBytes = NdefMap->StdMifareContainer.remainingSize; 2041 } 2042 2043 /* Remaining Bytes of length (L) in TLV <= internal length */ 2044 if ((NdefMap->TLVStruct.BytesRemainLinTLV <= 2045 NdefMap->StdMifareContainer.internalLength) && 2046 (RemainingBytes <= NdefMap->TLVStruct.BytesRemainLinTLV)) { 2047 memcpy(&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 2048 &(NdefMap->StdMifareContainer.internalBuf[(*TempintBytes)]), 2049 RemainingBytes); 2050 NdefMap->ApduBuffIndex += RemainingBytes; 2051 NdefMap->StdMifareContainer.remainingSize -= RemainingBytes; 2052 *TempintBytes += ((uint8_t)RemainingBytes); 2053 2054 /* copy the bytes to internal buffer, that are read, 2055 but not used for the user buffer */ 2056 memcpy(NdefMap->StdMifareContainer.internalBuf, 2057 &(NdefMap->StdMifareContainer.internalBuf[RemainingBytes]), 2058 (NdefMap->StdMifareContainer.internalLength - RemainingBytes)); 2059 2060 /* internal buffer length */ 2061 NdefMap->StdMifareContainer.internalLength -= RemainingBytes; 2062 2063 NdefMap->TLVStruct.BytesRemainLinTLV -= RemainingBytes; 2064 if (NdefMap->StdMifareContainer.internalLength == 2065 PH_FRINFC_MIFARESTD_VAL0) { 2066 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t)( 2067 ((NdefMap->StdMifareContainer.remainingSize == 2068 PH_FRINFC_MIFARESTD_VAL0) || 2069 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0)) 2070 ? PH_FRINFC_MIFARESTD_FLAG1 2071 : PH_FRINFC_MIFARESTD_FLAG0); 2072 2073 /* internal length bytes completed */ 2074 NdefMap->StdMifareContainer.currentBlock++; 2075 NdefMap->StdMifareContainer.NdefBlocks++; 2076 } 2077 2078 /* Remaining Bytes of length value in TLV */ 2079 if (NdefMap->TLVStruct.BytesRemainLinTLV == 0) { 2080 /* Remaining Bytes of length (L) in TLV is Zero means that the next 2081 coming bytes are containing type (T), length (L) in TLV */ 2082 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 2083 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2084 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2085 } 2086 /* call completion routine */ 2087 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2088 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 2089 } else if ((NdefMap->TLVStruct.BytesRemainLinTLV <= 2090 NdefMap->StdMifareContainer.internalLength) && 2091 (RemainingBytes > NdefMap->TLVStruct.BytesRemainLinTLV)) { 2092 memcpy(&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 2093 &(NdefMap->StdMifareContainer.internalBuf[(*TempintBytes)]), 2094 NdefMap->TLVStruct.BytesRemainLinTLV); 2095 2096 NdefMap->ApduBuffIndex += NdefMap->TLVStruct.BytesRemainLinTLV; 2097 NdefMap->StdMifareContainer.remainingSize -= 2098 NdefMap->TLVStruct.BytesRemainLinTLV; 2099 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG1; 2100 2101 *TempintBytes += ((uint8_t)NdefMap->TLVStruct.BytesRemainLinTLV); 2102 *Flag = PH_FRINFC_MIFARESTD_FLAG1; 2103 2104 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2105 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2106 2107 NdefMap->TLVStruct.BytesRemainLinTLV = PH_FRINFC_MIFARESTD_VAL0; 2108 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t)( 2109 ((NdefMap->StdMifareContainer.remainingSize == 2110 PH_FRINFC_MIFARESTD_VAL0) || 2111 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0)) 2112 ? PH_FRINFC_MIFARESTD_FLAG1 2113 : PH_FRINFC_MIFARESTD_FLAG0); 2114 2115 if (PH_FRINFC_MIFARESTD_FLAG1 == 2116 NdefMap->StdMifareContainer.ReadWriteCompleteFlag) { 2117 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2118 } 2119 2120 if (NdefMap->TLVStruct.BytesRemainLinTLV == 2121 NdefMap->StdMifareContainer.internalLength) { 2122 /* Remaining Bytes in Length (L) field of TLV is 0 */ 2123 NdefMap->TLVStruct.BytesRemainLinTLV = 2124 PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0; 2125 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 2126 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 2127 /* internal length bytes completed */ 2128 NdefMap->StdMifareContainer.currentBlock++; 2129 NdefMap->StdMifareContainer.NdefBlocks++; 2130 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 2131 if (Result == NFCSTATUS_SUCCESS) { 2132 Result = 2133 ((NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1) 2134 ? phFriNfc_MifStd_H_RdABlock(NdefMap) 2135 : phFriNfc_MifStd_H_AuthSector(NdefMap)); 2136 } 2137 } else { 2138 /* Remaining Bytes in Length (L) field of TLV is 0 */ 2139 NdefMap->TLVStruct.BytesRemainLinTLV = 2140 PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0; 2141 *Flag = PH_FRINFC_MIFARESTD_FLAG1; 2142 } 2143 } else if ((NdefMap->TLVStruct.BytesRemainLinTLV > 2144 NdefMap->StdMifareContainer.internalLength) && 2145 (RemainingBytes <= NdefMap->StdMifareContainer.internalLength)) { 2146 memcpy(&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 2147 &(NdefMap->StdMifareContainer.internalBuf[(*TempintBytes)]), 2148 RemainingBytes); 2149 2150 NdefMap->ApduBuffIndex += RemainingBytes; 2151 NdefMap->StdMifareContainer.remainingSize -= RemainingBytes; 2152 *TempintBytes += ((uint8_t)RemainingBytes); 2153 /* Remaining Bytes of length (L) in TLV */ 2154 NdefMap->TLVStruct.BytesRemainLinTLV -= RemainingBytes; 2155 2156 /* copy the bytes to internal buffer, that are read, 2157 but not used for the user buffer */ 2158 memcpy(NdefMap->StdMifareContainer.internalBuf, 2159 &(NdefMap->StdMifareContainer.internalBuf[RemainingBytes]), 2160 (NdefMap->StdMifareContainer.internalLength - RemainingBytes)); 2161 2162 /* internal buffer length */ 2163 NdefMap->StdMifareContainer.internalLength -= RemainingBytes; 2164 if (NdefMap->StdMifareContainer.internalLength == 2165 PH_FRINFC_MIFARESTD_VAL0) { 2166 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t)( 2167 ((NdefMap->StdMifareContainer.remainingSize == 2168 PH_FRINFC_MIFARESTD_VAL0) || 2169 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0)) 2170 ? PH_FRINFC_MIFARESTD_FLAG1 2171 : PH_FRINFC_MIFARESTD_FLAG0); 2172 2173 /* internal length bytes completed */ 2174 NdefMap->StdMifareContainer.currentBlock++; 2175 NdefMap->StdMifareContainer.NdefBlocks++; 2176 } 2177 2178 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 2179 CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2180 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 2181 } else { 2182 if ((NdefMap->TLVStruct.BytesRemainLinTLV > 2183 NdefMap->StdMifareContainer.internalLength) && 2184 (RemainingBytes > NdefMap->StdMifareContainer.internalLength)) { 2185 memcpy(&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), 2186 &(NdefMap->StdMifareContainer.internalBuf[(*TempintBytes)]), 2187 NdefMap->StdMifareContainer.internalLength); 2188 *Flag = PH_FRINFC_MIFARESTD_FLAG0; 2189 NdefMap->ApduBuffIndex += NdefMap->StdMifareContainer.internalLength; 2190 NdefMap->StdMifareContainer.remainingSize -= 2191 NdefMap->StdMifareContainer.internalLength; 2192 NdefMap->TLVStruct.BytesRemainLinTLV -= 2193 NdefMap->StdMifareContainer.internalLength; 2194 2195 if (NdefMap->TLVStruct.BytesRemainLinTLV != 2196 PH_FRINFC_MIFARESTD_NDEFTLV_LBYTES0) { 2197 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 2198 } 2199 2200 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 2201 /* internal length bytes completed */ 2202 NdefMap->StdMifareContainer.currentBlock++; 2203 NdefMap->StdMifareContainer.NdefBlocks++; 2204 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 2205 if (Result == NFCSTATUS_SUCCESS) { 2206 Result = 2207 ((NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1) 2208 ? phFriNfc_MifStd_H_RdABlock(NdefMap) 2209 : phFriNfc_MifStd_H_AuthSector(NdefMap)); 2210 } 2211 } 2212 } 2213 2214 if (CRFlag == PH_FRINFC_MIFARESTD_FLAG1) { 2215 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = (uint8_t)( 2216 ((NdefMap->StdMifareContainer.remainingSize == 2217 PH_FRINFC_MIFARESTD_VAL0) || 2218 (NdefMap->TLVStruct.BytesRemainLinTLV == PH_FRINFC_MIFARESTD_VAL0)) 2219 ? PH_FRINFC_MIFARESTD_FLAG1 2220 : PH_FRINFC_MIFARESTD_FLAG0); 2221 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; 2222 } 2223 2224 return Result; 2225 } 2226 2227 /****************************************************************************** 2228 * Function phFriNfc_MifStd_H_WriteNdefLen 2229 * 2230 * Description This function is Helper function for write ndef 2231 * to write the Length TLV. 2232 * 2233 * Returns This function return NFCSTATUS_PENDING in case of success 2234 * In case of failure returns other failure value. 2235 * 2236 ******************************************************************************/ 2237 static NFCSTATUS phFriNfc_MifStd_H_WriteNdefLen(phFriNfc_NdefMap_t* NdefMap) { 2238 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2239 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_WR_NDEF_LEN; 2240 2241 /* If Current block = Ndef TLV block then the starting point 2242 is writing from type of TLV 2243 Else */ 2244 2245 if (NdefMap->StdMifareContainer.currentBlock == 2246 NdefMap->TLVStruct.NdefTLVBlock) { 2247 if (NdefMap->TLVStruct.NULLTLVCount >= PH_FRINFC_MIFARESTD_VAL2) { 2248 phFriNfc_MifStd_H_fillTLV1(NdefMap); 2249 } else { 2250 phFriNfc_MifStd_H_fillTLV2(NdefMap); 2251 } 2252 } else { 2253 if (NdefMap->TLVStruct.NULLTLVCount >= PH_FRINFC_MIFARESTD_VAL2) { 2254 phFriNfc_MifStd_H_fillTLV1_1(NdefMap); 2255 } else { 2256 phFriNfc_MifStd_H_fillTLV2_1(NdefMap); 2257 } 2258 } 2259 2260 memcpy(NdefMap->StdMifareContainer.Buffer, 2261 &(NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL1]), 2262 PH_FRINFC_MIFARESTD_BYTES_READ); 2263 2264 /* Write from here */ 2265 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_WRITE; 2266 2267 NdefMap->Cmd.MfCmd = phHal_eMifareWrite16; 2268 2269 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 2270 /* Call the Overlapped HAL Transceive function */ 2271 Result = phFriNfc_ExtnsTransceive(NdefMap->pTransceiveInfo, NdefMap->Cmd, 2272 NdefMap->SendRecvBuf, NdefMap->SendLength, 2273 NdefMap->SendRecvLength); 2274 2275 return Result; 2276 } 2277 2278 /****************************************************************************** 2279 * Function phFriNfc_MifStd_H_RdWrReset 2280 * 2281 * Description It resets ndef TLV values. This is used when the offset 2282 * is BEGIN. 2283 * 2284 * Returns void 2285 * 2286 ******************************************************************************/ 2287 static void phFriNfc_MifStd_H_RdWrReset(phFriNfc_NdefMap_t* NdefMap) { 2288 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_BLK4; 2289 NdefMap->StdMifareContainer.NdefBlocks = PH_FRINFC_MIFARESTD_VAL1; 2290 NdefMap->TLVStruct.BytesRemainLinTLV = PH_FRINFC_MIFARESTD_VAL0; 2291 NdefMap->TLVStruct.LcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2292 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2293 NdefMap->TLVStruct.NdefTLVAuthFlag = PH_FRINFC_MIFARESTD_FLAG0; 2294 NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_MIFARESTD_MAD_BLK0; 2295 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL0; 2296 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL0; 2297 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 2298 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 2299 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 2300 NdefMap->StdMifareContainer.NFCforumSectFlag = PH_FRINFC_MIFARESTD_FLAG0; 2301 NdefMap->StdMifareContainer.FirstReadFlag = PH_FRINFC_MIFARESTD_FLAG1; 2302 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = PH_FRINFC_MIFARESTD_FLAG0; 2303 NdefMap->StdMifareContainer.remainingSize = 2304 (uint16_t)(NdefMap->StdMifareContainer.NoOfNdefCompBlocks * 2305 PH_FRINFC_MIFARESTD_BLOCK_BYTES); 2306 NdefMap->StdMifareContainer.WrLength = PH_FRINFC_MIFARESTD_VAL1; 2307 2308 return; 2309 } 2310 2311 /****************************************************************************** 2312 * Function phFriNfc_MifStd_H_RdtoWrNdefLen 2313 * 2314 * Description This function is used to read the first ndef compliant 2315 * block to change the length. 2316 * 2317 * Returns This function return NFCSTATUS_PENDING in case of success 2318 * In case of failure returns other failure value. 2319 * 2320 ******************************************************************************/ 2321 static NFCSTATUS phFriNfc_MifStd_H_RdtoWrNdefLen(phFriNfc_NdefMap_t* NdefMap) { 2322 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2323 2324 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RD_TO_WR_NDEF_LEN; 2325 2326 if (NdefMap->TLVStruct.NdefTLVAuthFlag == PH_FRINFC_MIFARESTD_FLAG1) { 2327 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 2328 Result = phFriNfc_MifStd_H_AuthSector(NdefMap); 2329 } else { 2330 NdefMap->SendRecvBuf[0] = NdefMap->StdMifareContainer.currentBlock; 2331 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_READ; 2332 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 2333 2334 NdefMap->Cmd.MfCmd = phHal_eMifareRead; 2335 2336 /* Call the Overlapped HAL Transceive function */ 2337 Result = phFriNfc_ExtnsTransceive(NdefMap->pTransceiveInfo, NdefMap->Cmd, 2338 NdefMap->SendRecvBuf, NdefMap->SendLength, 2339 NdefMap->SendRecvLength); 2340 } 2341 2342 return Result; 2343 } 2344 2345 /****************************************************************************** 2346 * Function phFriNfc_MifStd_H_SetNdefBlkAuth 2347 * 2348 * Description This function is used to set the authentication flag 2349 * for the ndef TLV block. 2350 * 2351 * Returns void 2352 * 2353 ******************************************************************************/ 2354 static void phFriNfc_MifStd_H_SetNdefBlkAuth(phFriNfc_NdefMap_t* NdefMap) { 2355 NdefMap->TLVStruct.NdefTLVAuthFlag = 2356 ((phFriNfc_MifStd_H_GetSect(NdefMap->TLVStruct.NdefTLVBlock) == 2357 phFriNfc_MifStd_H_GetSect(NdefMap->StdMifareContainer.currentBlock)) 2358 ? PH_FRINFC_MIFARESTD_FLAG0 2359 : PH_FRINFC_MIFARESTD_FLAG1); 2360 2361 return; 2362 } 2363 2364 /****************************************************************************** 2365 * Function phFriNfc_MifStd_H_GetActCardLen 2366 * 2367 * Description Helper function to get the actual length of card. 2368 * 2369 * Returns This function return NFCSTATUS_SUCCESS in case of success 2370 * In case of failure returns other failure value. 2371 * 2372 ******************************************************************************/ 2373 static NFCSTATUS phFriNfc_MifStd_H_GetActCardLen(phFriNfc_NdefMap_t* NdefMap) { 2374 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2375 2376 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_GET_ACT_CARDSIZE; 2377 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_GET_ACTSIZE_OPE; 2378 2379 Result = ((NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG0) 2380 ? phFriNfc_MifStd_H_AuthSector(NdefMap) 2381 : phFriNfc_MifStd_H_Rd16Bytes( 2382 NdefMap, NdefMap->StdMifareContainer.currentBlock)); 2383 2384 return Result; 2385 } 2386 2387 /****************************************************************************** 2388 * Function phFriNfc_MifStd_H_ChkTLVs 2389 * 2390 * Description Helper function to check all the TLVs. 2391 * 2392 * Returns This function return NFCSTATUS_SUCCESS in case of success 2393 * In case of failure returns other failure value. 2394 * 2395 ******************************************************************************/ 2396 static NFCSTATUS phFriNfc_MifStd_H_ChkTLVs(phFriNfc_NdefMap_t* NdefMap, 2397 uint8_t* CRFlag) { 2398 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2399 uint16_t TempLength = PH_FRINFC_MIFARESTD_VAL0, 2400 ShiftLength = PH_FRINFC_MIFARESTD_VAL0; 2401 uint8_t TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG0; 2402 2403 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_GET_ACTSIZE_OPE; 2404 TempLength = NdefMap->TLVStruct.NdefTLVByte; 2405 2406 for (;;) { 2407 if ((NdefMap->SendRecvBuf[TempLength] != PH_FRINFC_MIFARESTD_TERMTLV_T) && 2408 (NdefMap->SendRecvBuf[TempLength] != PH_FRINFC_MIFARESTD_NULLTLV_T) && 2409 (NdefMap->SendRecvBuf[TempLength] != PH_FRINFC_MIFARESTD_NDEFTLV_T) && 2410 (false == NdefMap->TLVStruct.NdefTLVFoundFlag)) { 2411 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT); 2412 NdefMap->TLVStruct.BytesRemainLinTLV = 0; 2413 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID; 2414 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2415 break; 2416 2417 } else if ((NdefMap->SendRecvBuf[TempLength] != 2418 PH_FRINFC_MIFARESTD_TERMTLV_T) && 2419 (NdefMap->SendRecvBuf[TempLength] != 2420 PH_FRINFC_MIFARESTD_NULLTLV_T)) { 2421 if (NdefMap->SendRecvBuf[TempLength] == PH_FRINFC_MIFARESTD_NDEFTLV_T) { 2422 NdefMap->TLVStruct.NdefTLVBlock = 2423 NdefMap->StdMifareContainer.currentBlock; 2424 NdefMap->TLVStruct.NdefTLVByte = (uint8_t)TempLength; 2425 NdefMap->TLVStruct.NdefTLVFoundFlag = 2426 ((NdefMap->SendRecvBuf[TempLength] == PH_FRINFC_MIFARESTD_NDEFTLV_T) 2427 ? PH_FRINFC_MIFARESTD_FLAG1 2428 : PH_FRINFC_MIFARESTD_FLAG0); 2429 2430 NdefMap->TLVStruct.NULLTLVCount = 2431 ((NdefMap->TLVStruct.NULLTLVCount == PH_FRINFC_MIFARESTD_VAL1) 2432 ? PH_FRINFC_MIFARESTD_VAL0 2433 : NdefMap->TLVStruct.NULLTLVCount); 2434 } else { 2435 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 2436 } 2437 2438 TempLength++; 2439 if (TempLength == PH_FRINFC_MIFARESTD_BYTES_READ) { 2440 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 2441 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL3; 2442 } 2443 Result = phFriNfc_MifStd_H_Chk16Bytes(NdefMap, TempLength); 2444 if (Result != NFCSTATUS_SUCCESS) { 2445 *CRFlag = (uint8_t)((Result == NFCSTATUS_PENDING) 2446 ? PH_FRINFC_MIFARESTD_FLAG0 2447 : PH_FRINFC_MIFARESTD_FLAG1); 2448 break; 2449 } 2450 2451 if (((((NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 2452 NdefMap->StdMifareContainer.NdefBlocks) * 2453 PH_FRINFC_MIFARESTD_BLOCK_BYTES) + 2454 (PH_FRINFC_MIFARESTD_BLOCK_BYTES - TempLength)) < 2455 NdefMap->SendRecvBuf[TempLength]) && 2456 ((NdefMap->SendRecvBuf[TempLength] < PH_FRINFC_MIFARESTD_NDEFTLV_L) && 2457 (NdefMap->TLVStruct.NdefTLVFoundFlag != PH_FRINFC_MIFARESTD_VAL1))) { 2458 /* Result = Error */ 2459 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 2460 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2461 break; 2462 } 2463 2464 if (((((NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 2465 NdefMap->StdMifareContainer.NdefBlocks) * 2466 PH_FRINFC_MIFARESTD_BLOCK_BYTES) + 2467 (PH_FRINFC_MIFARESTD_BLOCK_BYTES - TempLength)) < 2468 NdefMap->SendRecvBuf[TempLength]) && 2469 ((NdefMap->SendRecvBuf[TempLength] == PH_FRINFC_MIFARESTD_VAL0) && 2470 (NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_MIFARESTD_VAL1))) { 2471 /* Result = Error */ 2472 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 2473 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2474 break; 2475 } 2476 2477 if ((NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_MIFARESTD_FLAG1) && 2478 (NdefMap->SendRecvBuf[TempLength] < PH_FRINFC_MIFARESTD_NDEFTLV_L)) { 2479 Result = phFriNfc_MapTool_SetCardState( 2480 NdefMap, NdefMap->SendRecvBuf[TempLength]); 2481 NdefMap->TLVStruct.BytesRemainLinTLV = NdefMap->SendRecvBuf[TempLength]; 2482 NdefMap->StdMifareContainer.remainingSize -= PH_FRINFC_MIFARESTD_VAL2; 2483 /* This flag is set */ 2484 NdefMap->StdMifareContainer.remSizeUpdFlag = (uint8_t)( 2485 (NdefMap->TLVStruct.NULLTLVCount >= PH_FRINFC_MIFARESTD_VAL2) 2486 ? PH_FRINFC_MIFARESTD_FLAG0 2487 : PH_FRINFC_MIFARESTD_FLAG1); 2488 2489 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2490 break; 2491 } 2492 2493 NdefMap->StdMifareContainer.remainingSize -= 2494 ((NdefMap->SendRecvBuf[TempLength] < PH_FRINFC_MIFARESTD_NDEFTLV_L) 2495 ? (NdefMap->SendRecvBuf[TempLength] + PH_FRINFC_MIFARESTD_VAL2) 2496 : PH_FRINFC_MIFARESTD_VAL0); 2497 2498 if (NdefMap->SendRecvBuf[TempLength] == PH_FRINFC_MIFARESTD_VAL0) { 2499 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 2500 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2501 break; 2502 } 2503 2504 TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG0; 2505 /* get the next TLV after the proprietary TLV */ 2506 Result = 2507 ((NdefMap->SendRecvBuf[TempLength] < PH_FRINFC_MIFARESTD_NDEFTLV_L) 2508 ? phFriNfc_MifStd_H_GetNxtTLV(NdefMap, &TempLength, 2509 &TL4bytesFlag) 2510 : NFCSTATUS_PENDING); 2511 2512 if ((TempLength >= PH_FRINFC_MIFARESTD_BYTES_READ) && 2513 (Result == NFCSTATUS_SUCCESS)) { 2514 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2515 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL0; 2516 2517 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 2518 *CRFlag = (uint8_t)((Result != NFCSTATUS_PENDING) 2519 ? PH_FRINFC_MIFARESTD_FLAG1 2520 : PH_FRINFC_MIFARESTD_FLAG0); 2521 break; 2522 } else { 2523 if (Result == NFCSTATUS_PENDING) { 2524 TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG1; 2525 Result = ((NdefMap->SendRecvBuf[TempLength] == 2526 PH_FRINFC_MIFARESTD_NDEFTLV_L) 2527 ? NFCSTATUS_SUCCESS 2528 : (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 2529 NFCSTATUS_INVALID_PARAMETER))); 2530 2531 if (Result != NFCSTATUS_SUCCESS) { 2532 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2533 break; 2534 } 2535 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 2536 TempLength++; 2537 /* Check 0xFF */ 2538 if (TempLength == PH_FRINFC_MIFARESTD_BYTES_READ) { 2539 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 2540 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL2; 2541 } 2542 Result = phFriNfc_MifStd_H_Chk16Bytes(NdefMap, TempLength); 2543 if (Result != NFCSTATUS_SUCCESS) { 2544 break; 2545 } 2546 2547 ShiftLength = NdefMap->SendRecvBuf[TempLength]; 2548 TempLength++; 2549 if (TempLength == PH_FRINFC_MIFARESTD_BYTES_READ) { 2550 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 2551 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL1; 2552 NdefMap->TLVStruct.prevLenByteValue = 2553 NdefMap->SendRecvBuf[(TempLength - PH_FRINFC_MIFARESTD_VAL1)]; 2554 } 2555 Result = phFriNfc_MifStd_H_Chk16Bytes(NdefMap, TempLength); 2556 if (Result != NFCSTATUS_SUCCESS) { 2557 break; 2558 } 2559 2560 if ((((NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 2561 NdefMap->StdMifareContainer.NdefBlocks) * 2562 PH_FRINFC_MIFARESTD_BLOCK_BYTES) + 2563 (PH_FRINFC_MIFARESTD_BLOCK_BYTES - TempLength)) < 2564 ((ShiftLength << 8) + NdefMap->SendRecvBuf[TempLength])) { 2565 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 2566 NFCSTATUS_INVALID_REMOTE_DEVICE); 2567 2568 break; 2569 } 2570 2571 if (NdefMap->TLVStruct.NdefTLVFoundFlag == 2572 PH_FRINFC_MIFARESTD_FLAG1) { 2573 ShiftLength = 2574 ((ShiftLength << 8) + NdefMap->SendRecvBuf[TempLength]); 2575 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength; 2576 Result = phFriNfc_MapTool_SetCardState(NdefMap, ShiftLength); 2577 NdefMap->StdMifareContainer.remainingSize -= 2578 PH_FRINFC_MIFARESTD_VAL4; 2579 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2580 break; 2581 } 2582 2583 NdefMap->StdMifareContainer.remainingSize -= 2584 ((ShiftLength << 8) + 2585 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)]); 2586 TempLength++; 2587 2588 /* get the next TLV after the proprietary TLV */ 2589 Result = 2590 phFriNfc_MifStd_H_GetNxtTLV(NdefMap, &TempLength, &TL4bytesFlag); 2591 2592 if ((TempLength >= PH_FRINFC_MIFARESTD_BYTES_READ) && 2593 (Result == NFCSTATUS_SUCCESS)) { 2594 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 2595 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_MIFARESTD_VAL0; 2596 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 2597 2598 break; 2599 } 2600 break; 2601 } 2602 } 2603 } else if ((NdefMap->SendRecvBuf[TempLength] == 2604 PH_FRINFC_MIFARESTD_TERMTLV_T) && 2605 (NdefMap->TLVStruct.NdefTLVFoundFlag == 2606 PH_FRINFC_MIFARESTD_FLAG0)) { 2607 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 2608 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 2609 PH_FRINFC_MIFARESTD_FLAG1; 2610 break; 2611 2612 } else if (NdefMap->SendRecvBuf[TempLength] == 2613 PH_FRINFC_MIFARESTD_NULLTLV_T) { 2614 TempLength++; 2615 NdefMap->TLVStruct.NULLTLVCount += PH_FRINFC_MIFARESTD_VAL1; 2616 ShiftLength = 2617 NdefMap->SendRecvBuf[(TempLength - PH_FRINFC_MIFARESTD_VAL1)]; 2618 NdefMap->StdMifareContainer.remainingSize -= PH_FRINFC_MIFARESTD_VAL1; 2619 if (NdefMap->StdMifareContainer.remainingSize < 2620 ((ShiftLength << 8) + NdefMap->SendRecvBuf[TempLength])) { 2621 Result = 2622 PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_REMOTE_DEVICE); 2623 break; 2624 } 2625 Result = phFriNfc_MifStd_H_Chk16Bytes(NdefMap, TempLength); 2626 if (Result != NFCSTATUS_SUCCESS) { 2627 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL0; 2628 break; 2629 } 2630 } else { 2631 if ((NdefMap->SendRecvBuf[TempLength] == PH_FRINFC_MIFARESTD_TERMTLV_T) && 2632 (NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_MIFARESTD_FLAG1)) { 2633 TempLength++; 2634 Result = NFCSTATUS_SUCCESS; 2635 NdefMap->StdMifareContainer.remainingSize -= PH_FRINFC_MIFARESTD_VAL1; 2636 } 2637 } 2638 } 2639 2640 if (NdefMap->TLVStruct.BytesRemainLinTLV > 2641 NdefMap->StdMifareContainer.remainingSize) { 2642 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_FORMAT); 2643 } else { 2644 if (NdefMap->StdMifareContainer.remainingSize == PH_FRINFC_MIFARESTD_VAL0) { 2645 Result = 2646 ((NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_MIFARESTD_FLAG1) 2647 ? NFCSTATUS_SUCCESS 2648 : (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, 2649 NFCSTATUS_INVALID_PARAMETER))); 2650 } 2651 } 2652 2653 return Result; 2654 } 2655 2656 /****************************************************************************** 2657 * Function phFriNfc_MifStd_H_GetNxtTLV 2658 * 2659 * Description This is a Helper function to get the next TLV. 2660 * 2661 * Returns This function return NFCSTATUS_SUCCESS in case of success 2662 * In case of failure returns other failure value. 2663 * 2664 ******************************************************************************/ 2665 static NFCSTATUS phFriNfc_MifStd_H_GetNxtTLV(phFriNfc_NdefMap_t* NdefMap, 2666 uint16_t* TempLength, 2667 uint8_t* TL4bytesFlag) { 2668 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2669 uint16_t LengthRemaining = PH_FRINFC_MIFARESTD_VAL0, 2670 TempLen = PH_FRINFC_MIFARESTD_VAL0, 2671 ShiftLength = PH_FRINFC_MIFARESTD_VAL0; 2672 2673 TempLen = (*TempLength); 2674 LengthRemaining = 2675 (PH_FRINFC_MIFARESTD_BYTES_READ - (TempLen + PH_FRINFC_MIFARESTD_VAL1)); 2676 2677 if (*TL4bytesFlag == PH_FRINFC_MIFARESTD_FLAG0) { 2678 (*TempLength) += (NdefMap->SendRecvBuf[TempLen] + PH_FRINFC_MIFARESTD_VAL1); 2679 2680 if (NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_MIFARESTD_FLAG0) { 2681 LengthRemaining = 2682 (((*TempLength) < PH_FRINFC_MIFARESTD_BYTES_READ) 2683 ? PH_FRINFC_MIFARESTD_VAL0 2684 : (NdefMap->SendRecvBuf[TempLen] - LengthRemaining)); 2685 } else { 2686 LengthRemaining = 2687 (((*TempLength) < PH_FRINFC_MIFARESTD_BYTES_READ) 2688 ? PH_FRINFC_MIFARESTD_VAL0 2689 : (NdefMap->SendRecvBuf[TempLen] - LengthRemaining)); 2690 } 2691 } else { 2692 *TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG0; 2693 if (NdefMap->TLVStruct.NoLbytesinTLV == PH_FRINFC_MIFARESTD_VAL1) { 2694 ShiftLength = NdefMap->TLVStruct.prevLenByteValue; 2695 (*TempLength) += ((ShiftLength << 8) + NdefMap->SendRecvBuf[TempLen] + 2696 PH_FRINFC_MIFARESTD_VAL1); 2697 2698 LengthRemaining = (((ShiftLength << 8) + NdefMap->SendRecvBuf[TempLen]) - 2699 LengthRemaining); 2700 } else { 2701 ShiftLength = NdefMap->SendRecvBuf[(TempLen - PH_FRINFC_MIFARESTD_VAL1)]; 2702 (*TempLength) += ((ShiftLength << 8) + NdefMap->SendRecvBuf[TempLen] + 2703 PH_FRINFC_MIFARESTD_VAL1); 2704 2705 LengthRemaining = (((ShiftLength << 8) + NdefMap->SendRecvBuf[TempLen]) - 2706 LengthRemaining); 2707 } 2708 } 2709 2710 NdefMap->TLVStruct.NdefTLVByte = 2711 (uint8_t)(((*TempLength) < PH_FRINFC_MIFARESTD_BYTES_READ) 2712 ? (*TempLength) 2713 : (LengthRemaining % PH_FRINFC_MIFARESTD_BYTES_READ)); 2714 2715 while (LengthRemaining != PH_FRINFC_MIFARESTD_VAL0) { 2716 NdefMap->StdMifareContainer.currentBlock++; 2717 NdefMap->StdMifareContainer.NdefBlocks++; 2718 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 2719 LengthRemaining -= ((LengthRemaining <= PH_FRINFC_MIFARESTD_BYTES_READ) 2720 ? LengthRemaining 2721 : PH_FRINFC_MIFARESTD_BYTES_READ); 2722 } 2723 2724 if (NdefMap->TLVStruct.NdefTLVByte == PH_FRINFC_MIFARESTD_VAL0) { 2725 NdefMap->StdMifareContainer.currentBlock++; 2726 NdefMap->StdMifareContainer.NdefBlocks++; 2727 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 2728 } 2729 2730 return Result; 2731 } 2732 2733 /****************************************************************************** 2734 * Function phFriNfc_MifStd_H_Chk16Bytes 2735 * 2736 * Description This Helper function is used to know whether the read 2737 * 16 bytes are parsed completely. 2738 * 2739 * Returns This function return NFCSTATUS_SUCCESS in case of success 2740 * In case of failure returns other failure value. 2741 * 2742 ******************************************************************************/ 2743 static NFCSTATUS phFriNfc_MifStd_H_Chk16Bytes(phFriNfc_NdefMap_t* NdefMap, 2744 uint16_t TempLength) { 2745 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2746 2747 if (TempLength == PH_FRINFC_MIFARESTD_BYTES_READ) { 2748 NdefMap->StdMifareContainer.currentBlock++; 2749 NdefMap->StdMifareContainer.NdefBlocks++; 2750 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 2751 2752 Result = 2753 ((NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG1) 2754 ? phFriNfc_MifStd_H_GetActCardLen(NdefMap) 2755 : phFriNfc_MifStd_H_AuthSector(NdefMap)); 2756 } 2757 2758 return Result; 2759 } 2760 2761 /****************************************************************************** 2762 * Function phFriNfc_MifStd_H_ChkRemainTLVs 2763 * 2764 * Description This function is used to know whether the read 2765 * 16 bytes are parsed completely. 2766 * 2767 * Returns This function return NFCSTATUS_SUCCESS in case of success 2768 * In case of failure returns other failure value. 2769 * 2770 ******************************************************************************/ 2771 static NFCSTATUS phFriNfc_MifStd_H_ChkRemainTLVs(phFriNfc_NdefMap_t* NdefMap, 2772 uint8_t* CRFlag, 2773 uint8_t* NDEFFlag) { 2774 NFCSTATUS Result = NFCSTATUS_SUCCESS; 2775 uint16_t TempLength = PH_FRINFC_MIFARESTD_VAL0, 2776 ShiftLength = PH_FRINFC_MIFARESTD_VAL0; 2777 uint8_t TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG0; 2778 2779 switch (NdefMap->TLVStruct.NoLbytesinTLV) { 2780 case PH_FRINFC_MIFARESTD_VAL3: 2781 /* if TLV is found then set card state */ 2782 Result = 2783 ((NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_MIFARESTD_FLAG1) 2784 ? phFriNfc_MapTool_SetCardState(NdefMap, 2785 NdefMap->SendRecvBuf[TempLength]) 2786 : Result); 2787 2788 Result = 2789 ((NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_MIFARESTD_FLAG1) 2790 ? 1 2791 : Result); 2792 2793 /* Check the length field is less than or 2794 equal to 0xFF if yes enter below statement 2795 else enter else if*/ 2796 if ((NdefMap->SendRecvBuf[TempLength] < PH_FRINFC_MIFARESTD_NDEFTLV_L) && 2797 (Result == NFCSTATUS_SUCCESS)) { 2798 NdefMap->StdMifareContainer.remainingSize -= PH_FRINFC_MIFARESTD_VAL2; 2799 2800 Result = 2801 ((NdefMap->SendRecvBuf[TempLength] > 2802 NdefMap->StdMifareContainer.remainingSize) 2803 ? (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_FORMAT)) 2804 : Result); 2805 TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG0; 2806 if ((NdefMap->TLVStruct.NdefTLVFoundFlag == 2807 PH_FRINFC_MIFARESTD_FLAG1) && 2808 (Result == NFCSTATUS_SUCCESS)) { 2809 NdefMap->TLVStruct.BytesRemainLinTLV = 2810 NdefMap->SendRecvBuf[TempLength]; 2811 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2812 2813 } else if (Result == NFCSTATUS_SUCCESS) { 2814 TempLength++; 2815 Result = 2816 phFriNfc_MifStd_H_GetNxtTLV(NdefMap, &TempLength, &TL4bytesFlag); 2817 2818 NdefMap->StdMifareContainer.remainingSize -= 2819 NdefMap->SendRecvBuf[TempLength]; 2820 if ((TempLength >= PH_FRINFC_MIFARESTD_BYTES_READ) && 2821 (*CRFlag == PH_FRINFC_MIFARESTD_FLAG0)) { 2822 *NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 2823 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 2824 } 2825 } 2826 2827 else { 2828 /* do nothing */ 2829 } 2830 } else if ((NdefMap->SendRecvBuf[TempLength] == 2831 PH_FRINFC_MIFARESTD_NDEFTLV_L) && 2832 (Result == NFCSTATUS_SUCCESS)) { 2833 TempLength++; 2834 NdefMap->StdMifareContainer.remainingSize -= PH_FRINFC_MIFARESTD_VAL4; 2835 TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG0; 2836 Result = 2837 (((((uint16_t)NdefMap->SendRecvBuf[TempLength] << 8) + 2838 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)]) > 2839 NdefMap->StdMifareContainer.remainingSize) 2840 ? (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_FORMAT)) 2841 : Result); 2842 if ((NdefMap->TLVStruct.NdefTLVFoundFlag == 2843 PH_FRINFC_MIFARESTD_FLAG1) && 2844 (Result == NFCSTATUS_SUCCESS)) { 2845 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 2846 NdefMap->TLVStruct.BytesRemainLinTLV = 2847 (((uint16_t)NdefMap->SendRecvBuf[TempLength] << 8) + 2848 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)]); 2849 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2850 } else if (Result == NFCSTATUS_SUCCESS) { 2851 TempLength++; 2852 2853 Result = 2854 phFriNfc_MifStd_H_GetNxtTLV(NdefMap, &TempLength, &TL4bytesFlag); 2855 NdefMap->StdMifareContainer.remainingSize -= 2856 (((uint16_t)NdefMap->SendRecvBuf[TempLength] << 8) + 2857 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)]); 2858 2859 *NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 2860 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 2861 } else { 2862 /* do nothing */ 2863 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2864 } 2865 } else { 2866 /* Result = Error */ 2867 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_FORMAT); 2868 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2869 } 2870 break; 2871 2872 case PH_FRINFC_MIFARESTD_VAL2: 2873 case PH_FRINFC_MIFARESTD_VAL1: 2874 ShiftLength = 2875 ((NdefMap->TLVStruct.NoLbytesinTLV == PH_FRINFC_MIFARESTD_VAL1) 2876 ? ((NdefMap->TLVStruct.prevLenByteValue << 8) + 2877 NdefMap->SendRecvBuf[TempLength]) 2878 : (((uint16_t)NdefMap->SendRecvBuf[TempLength] << 8) + 2879 NdefMap 2880 ->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)])); 2881 if ((((NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 2882 NdefMap->StdMifareContainer.NdefBlocks) * 2883 PH_FRINFC_MIFARESTD_BLOCK_BYTES) + 2884 (PH_FRINFC_MIFARESTD_BLOCK_BYTES - TempLength)) < ShiftLength) { 2885 /* Result = Error */ 2886 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 2887 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2888 } else { 2889 NdefMap->StdMifareContainer.remainingSize -= PH_FRINFC_MIFARESTD_VAL2; 2890 if (NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_MIFARESTD_FLAG1) { 2891 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength; 2892 if (NdefMap->TLVStruct.BytesRemainLinTLV > 2893 NdefMap->StdMifareContainer.remainingSize) { 2894 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_FORMAT); 2895 } 2896 *CRFlag = PH_FRINFC_MIFARESTD_FLAG1; 2897 *NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 2898 } else { 2899 NdefMap->StdMifareContainer.remainingSize -= ShiftLength; 2900 *CRFlag = PH_FRINFC_MIFARESTD_FLAG0; 2901 TempLength += PH_FRINFC_MIFARESTD_VAL2; 2902 TL4bytesFlag = PH_FRINFC_MIFARESTD_FLAG1; 2903 Result = ((NdefMap->TLVStruct.NdefTLVFoundFlag == 2904 PH_FRINFC_MIFARESTD_FLAG1) 2905 ? NFCSTATUS_SUCCESS 2906 : phFriNfc_MifStd_H_GetNxtTLV(NdefMap, &TempLength, 2907 &TL4bytesFlag)); 2908 2909 *NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 2910 Result = phFriNfc_MifStd_H_GetActCardLen(NdefMap); 2911 } 2912 } 2913 break; 2914 2915 default: 2916 break; 2917 } 2918 2919 return Result; 2920 } 2921 2922 /****************************************************************************** 2923 * Function phFriNfc_MifStd_H_Get1kStTrail 2924 * 2925 * Description This function is used to get the Mifare 1k Sector Trailer. 2926 * 2927 * Returns void 2928 * 2929 ******************************************************************************/ 2930 static void phFriNfc_MifStd_H_Get1kStTrail(phFriNfc_NdefMap_t* NdefMap) { 2931 switch ((NdefMap->StdMifareContainer.currentBlock % 4)) { 2932 case PH_FRINFC_MIFARESTD_VAL0: 2933 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 2934 (NdefMap->StdMifareContainer.currentBlock + 2935 PH_FRINFC_MIFARESTD_MAD_BLK3); 2936 break; 2937 2938 case PH_FRINFC_MIFARESTD_VAL1: 2939 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 2940 (NdefMap->StdMifareContainer.currentBlock + 2941 PH_FRINFC_MIFARESTD_MAD_BLK2); 2942 break; 2943 2944 case PH_FRINFC_MIFARESTD_VAL2: 2945 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 2946 (NdefMap->StdMifareContainer.currentBlock + 2947 PH_FRINFC_MIFARESTD_MAD_BLK1); 2948 break; 2949 2950 default: 2951 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 2952 NdefMap->StdMifareContainer.currentBlock; 2953 break; 2954 } 2955 2956 return; 2957 } 2958 2959 /****************************************************************************** 2960 * Function phFriNfc_MifStd_H_Get4kStTrail 2961 * 2962 * Description This function gets the Mifare 4k Sector Trailer. 2963 * 2964 * Returns void 2965 * 2966 ******************************************************************************/ 2967 static void phFriNfc_MifStd_H_Get4kStTrail(phFriNfc_NdefMap_t* NdefMap) { 2968 switch ((NdefMap->StdMifareContainer.currentBlock % 16)) { 2969 case PH_FRINFC_MIFARESTD_MAD_BLK0: 2970 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 2971 (NdefMap->StdMifareContainer.currentBlock + 2972 PH_FRINFC_MIFARESTD_BLK15); 2973 break; 2974 2975 case PH_FRINFC_MIFARESTD_MAD_BLK1: 2976 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 2977 (NdefMap->StdMifareContainer.currentBlock + 2978 PH_FRINFC_MIFARESTD_BLK14); 2979 break; 2980 2981 case PH_FRINFC_MIFARESTD_MAD_BLK2: 2982 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 2983 (NdefMap->StdMifareContainer.currentBlock + 2984 PH_FRINFC_MIFARESTD_BLK13); 2985 break; 2986 2987 case PH_FRINFC_MIFARESTD_MAD_BLK3: 2988 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 2989 (NdefMap->StdMifareContainer.currentBlock + 2990 PH_FRINFC_MIFARESTD_BLK12); 2991 break; 2992 2993 case PH_FRINFC_MIFARESTD_BLK4: 2994 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 2995 (NdefMap->StdMifareContainer.currentBlock + 2996 PH_FRINFC_MIFARESTD_BLK11); 2997 break; 2998 2999 case PH_FRINFC_MIFARESTD_BLK5: 3000 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3001 (NdefMap->StdMifareContainer.currentBlock + 3002 PH_FRINFC_MIFARESTD_BLK10); 3003 break; 3004 3005 case PH_FRINFC_MIFARESTD_BLK6: 3006 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3007 (NdefMap->StdMifareContainer.currentBlock + PH_FRINFC_MIFARESTD_BLK9); 3008 break; 3009 3010 case PH_FRINFC_MIFARESTD_BLK7: 3011 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3012 (NdefMap->StdMifareContainer.currentBlock + PH_FRINFC_MIFARESTD_BLK8); 3013 break; 3014 3015 case PH_FRINFC_MIFARESTD_BLK8: 3016 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3017 (NdefMap->StdMifareContainer.currentBlock + PH_FRINFC_MIFARESTD_BLK7); 3018 break; 3019 3020 case PH_FRINFC_MIFARESTD_BLK9: 3021 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3022 (NdefMap->StdMifareContainer.currentBlock + PH_FRINFC_MIFARESTD_BLK6); 3023 break; 3024 3025 case PH_FRINFC_MIFARESTD_BLK10: 3026 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3027 (NdefMap->StdMifareContainer.currentBlock + PH_FRINFC_MIFARESTD_BLK5); 3028 break; 3029 3030 case PH_FRINFC_MIFARESTD_BLK11: 3031 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3032 (NdefMap->StdMifareContainer.currentBlock + PH_FRINFC_MIFARESTD_BLK4); 3033 break; 3034 3035 case PH_FRINFC_MIFARESTD_BLK12: 3036 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3037 (NdefMap->StdMifareContainer.currentBlock + 3038 PH_FRINFC_MIFARESTD_MAD_BLK3); 3039 break; 3040 3041 case PH_FRINFC_MIFARESTD_BLK13: 3042 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3043 (NdefMap->StdMifareContainer.currentBlock + 3044 PH_FRINFC_MIFARESTD_MAD_BLK2); 3045 break; 3046 3047 case PH_FRINFC_MIFARESTD_BLK14: 3048 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3049 (NdefMap->StdMifareContainer.currentBlock + 3050 PH_FRINFC_MIFARESTD_MAD_BLK1); 3051 break; 3052 3053 default: 3054 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3055 NdefMap->StdMifareContainer.currentBlock; 3056 break; 3057 } 3058 3059 return; 3060 } 3061 3062 /****************************************************************************** 3063 * Function phFriNfc_MifStd_H_ProChkNdef 3064 * 3065 * Description This function processes the check ndef call. 3066 * 3067 * Returns This function return NFCSTATUS_PENDING in case of success 3068 * In case of failure returns other failure value. 3069 * 3070 ******************************************************************************/ 3071 static NFCSTATUS phFriNfc_MifStd_H_ProChkNdef(phFriNfc_NdefMap_t* NdefMap) { 3072 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3073 3074 /* Copy remaining bytes into the AID array 3075 from Receive Buffer till array number 7 in aid */ 3076 if (NdefMap->StdMifareContainer.currentBlock == PH_FRINFC_MIFARESTD_VAL1) { 3077 /* Helper Function to Store AID Information */ 3078 phFriNfc_MifStd_H_fillAIDarray(NdefMap); 3079 3080 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_VAL2; 3081 /* read remaining AIDs from block number 2 */ 3082 Result = ((NdefMap->StdMifareContainer.aidCompleteFlag == 3083 PH_FRINFC_MIFARESTD_FLAG1) 3084 ? Result 3085 : phFriNfc_MifareStdMap_ChkNdef(NdefMap)); 3086 } else if (((NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD) && 3087 (NdefMap->StdMifareContainer.currentBlock == 3088 PH_FRINFC_MIFARESTD_MAD_BLK2)) || 3089 ((NdefMap->StdMifareContainer.currentBlock == 3090 PH_FRINFC_MIFARESTD_MAD_BLK66) && 3091 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD || 3092 NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD))) { 3093 /* Helper Function to Store AID Information */ 3094 phFriNfc_MifStd_H_fillAIDarray(NdefMap); 3095 3096 NdefMap->StdMifareContainer.aidCompleteFlag = PH_FRINFC_MIFARESTD_FLAG1; 3097 } /* Mifare 1k and Mifare 4k end Check */ 3098 else if ((NdefMap->StdMifareContainer.currentBlock > 3099 PH_FRINFC_MIFARESTD_VAL1) && 3100 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD || 3101 NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD)) { 3102 phFriNfc_MifStd_H_fillAIDarray(NdefMap); 3103 /* read remaining AIDs from block number 2 */ 3104 /* Mifare 4k Helper Function */ 3105 Result = ((NdefMap->StdMifareContainer.aidCompleteFlag == 3106 PH_FRINFC_MIFARESTD_FLAG1) 3107 ? Result 3108 : phFriNfc_MifStd4k_H_CheckNdef(NdefMap)); 3109 } /* Card Type 4k Check */ 3110 else { 3111 /* Since we have decided temporarily not to go 3112 for any new error codes we are using 3113 NFCSTATUS_INVALID_PARAMETER even though it is not 3114 the relevant error code here TBD */ 3115 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 3116 } 3117 3118 if (NdefMap->StdMifareContainer.aidCompleteFlag == 3119 PH_FRINFC_MIFARESTD_FLAG1) { 3120 NdefMap->StdMifareContainer.ChkNdefCompleteFlag = PH_FRINFC_MIFARESTD_FLAG1; 3121 /* The check for NDEF compliant information is now over for 3122 the Mifare 1K card. 3123 Update(decrement) the NoOfNdefCompBlocks as much required, 3124 depending on the NDEF compliant information found */ 3125 /* Check the Sectors are Ndef Compliant */ 3126 phFriNfc_MifStd_H_ChkNdefCmpltSects(NdefMap); 3127 if ((NdefMap->StdMifareContainer.NoOfNdefCompBlocks == 0) || 3128 (NdefMap->StdMifareContainer.NoOfNdefCompBlocks > 255)) { 3129 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT); 3130 } else { 3131 NdefMap->StdMifareContainer.aidCompleteFlag = PH_FRINFC_MIFARESTD_FLAG0; 3132 NdefMap->StdMifareContainer.NFCforumSectFlag = PH_FRINFC_MIFARESTD_FLAG0; 3133 NdefMap->StdMifareContainer.currentBlock = PH_FRINFC_MIFARESTD_BLK4; 3134 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3135 Result = ((Result != NFCSTATUS_SUCCESS) 3136 ? Result 3137 : phFriNfc_MifStd_H_AuthSector(NdefMap)); 3138 } 3139 } 3140 3141 return Result; 3142 } 3143 3144 /****************************************************************************** 3145 * Function phFriNfc_MifStd_H_ProAuth 3146 * 3147 * Description This function process the authentication of a sector. 3148 * 3149 * Returns This function return NFCSTATUS_SUCCESS in case of success 3150 * In case of failure returns other failure value. 3151 * 3152 ******************************************************************************/ 3153 static NFCSTATUS phFriNfc_MifStd_H_ProAuth(phFriNfc_NdefMap_t* NdefMap) { 3154 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3155 3156 if (NdefMap->TLVStruct.NdefTLVAuthFlag == PH_FRINFC_MIFARESTD_FLAG1) { 3157 NdefMap->TLVStruct.NdefTLVAuthFlag = PH_FRINFC_MIFARESTD_FLAG0; 3158 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG1; 3159 Result = phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap); 3160 } else { 3161 NdefMap->StdMifareContainer.AuthDone = 1; 3162 NdefMap->StdMifareContainer.ReadAcsBitFlag = 1; 3163 Result = phFriNfc_MifStd_H_RdAcsBit(NdefMap); 3164 } 3165 3166 return Result; 3167 } 3168 3169 /****************************************************************************** 3170 * Function phFriNfc_MifStd_H_Rd16Bytes 3171 * 3172 * Description This function reads 16 bytes from a specifed block no. 3173 * 3174 * Returns This function return NFCSTATUS_PENDING in case of success 3175 * In case of failure returns other failure value. 3176 * 3177 ******************************************************************************/ 3178 static NFCSTATUS phFriNfc_MifStd_H_Rd16Bytes(phFriNfc_NdefMap_t* NdefMap, 3179 uint8_t BlockNo) { 3180 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3181 3182 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = BlockNo; 3183 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_READ; 3184 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 3185 NdefMap->Cmd.MfCmd = phHal_eMifareRead; 3186 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 3187 NdefMap->MapCompletionInfo.Context = NdefMap; 3188 3189 /* Call the Overlapped HAL Transceive function */ 3190 Result = phFriNfc_ExtnsTransceive(NdefMap->pTransceiveInfo, NdefMap->Cmd, 3191 NdefMap->SendRecvBuf, NdefMap->SendLength, 3192 NdefMap->SendRecvLength); 3193 3194 return Result; 3195 } 3196 3197 /****************************************************************************** 3198 * Function phFriNfc_MifStd_H_ProAcsBits 3199 * 3200 * Description It processes access bits of the sector trailer. 3201 * 3202 * Returns This function return NFCSTATUS_SUCCESS in case of success 3203 * In case of failure returns other failure value. 3204 * 3205 ******************************************************************************/ 3206 static NFCSTATUS phFriNfc_MifStd_H_ProAcsBits(phFriNfc_NdefMap_t* NdefMap) { 3207 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3208 uint8_t CRFlag = PH_FRINFC_MIFARESTD_FLAG0; 3209 3210 if (*NdefMap->SendRecvLength == PH_FRINFC_MIFARESTD_BYTES_READ) { 3211 if (NdefMap->StdMifareContainer.ReadAcsBitFlag == 3212 PH_FRINFC_MIFARESTD_FLAG1) { 3213 /* check for the correct access bits */ 3214 Result = phFriNfc_MifStd_H_ChkAcsBit(NdefMap); 3215 3216 if ((NdefMap->StdMifareContainer.ChkNdefFlag == 3217 PH_FRINFC_MIFARESTD_FLAG1) && 3218 (Result == NFCSTATUS_SUCCESS)) { 3219 if (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID) { 3220 NdefMap->StdMifareContainer.NoOfNdefCompBlocks = 3221 ((NdefMap->StdMifareContainer.currentBlock >= 3222 PH_FRINFC_MIFARESTD4K_BLK128) 3223 ? (NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 3224 PH_FRINFC_MIFARESTD_BLK15) 3225 : (NdefMap->StdMifareContainer.NoOfNdefCompBlocks - 3226 PH_FRINFC_MIFARESTD_MAD_BLK3)); 3227 3228 NdefMap->StdMifareContainer.ProprforumSectFlag = 3229 ((NdefMap->StdMifareContainer.NFCforumSectFlag == 3230 PH_FRINFC_MIFARESTD_FLAG1) 3231 ? PH_FRINFC_MIFARESTD_PROP_2ND_CONFIG 3232 : PH_FRINFC_MIFARESTD_PROP_3RD_CONFIG); 3233 3234 Result = phFriNfc_MifStd_H_ProStatNotValid(NdefMap, Result); 3235 } else { 3236 NdefMap->StdMifareContainer.NFCforumSectFlag = 3237 (((NdefMap->StdMifareContainer.currentBlock == 64) && 3238 ((NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD) || 3239 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD))) 3240 ? NdefMap->StdMifareContainer.NFCforumSectFlag 3241 : PH_FRINFC_MIFARESTD_FLAG1); 3242 } 3243 3244 if (NdefMap->StdMifareContainer.ProprforumSectFlag != 3245 PH_FRINFC_MIFARESTD_PROP_2ND_CONFIG) { 3246 NdefMap->StdMifareContainer.ReadAcsBitFlag = 3247 PH_FRINFC_MIFARESTD_FLAG0; 3248 /* ((NdefMap->StdMifareContainer.ReadCompleteFlag == 3249 PH_FRINFC_MIFARESTD_FLAG1)? 3250 PH_FRINFC_MIFARESTD_FLAG0: 3251 PH_FRINFC_MIFARESTD_FLAG1);*/ 3252 3253 NdefMap->StdMifareContainer.ReadCompleteFlag = (uint8_t)( 3254 (((((NdefMap->StdMifareContainer.currentBlock + 3255 PH_FRINFC_MIFARESTD_VAL4) >= 3256 PH_FRINFC_MIFARESTD1K_MAX_BLK) && 3257 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD)) && 3258 (NdefMap->StdMifareContainer.ReadCompleteFlag == 3259 PH_FRINFC_MIFARESTD_FLAG0)) || 3260 (NdefMap->StdMifareContainer.ReadCompleteFlag == 3261 PH_FRINFC_MIFARESTD_FLAG1)) 3262 ? PH_FRINFC_MIFARESTD_FLAG1 3263 : PH_FRINFC_MIFARESTD_FLAG0); 3264 3265 NdefMap->StdMifareContainer.ReadCompleteFlag = (uint8_t)( 3266 (((((uint16_t)(NdefMap->StdMifareContainer.currentBlock + 3267 PH_FRINFC_MIFARESTD_VAL4) >= 3268 PH_FRINFC_MIFARESTD4K_MAX_BLK) && 3269 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD)) && 3270 (NdefMap->StdMifareContainer.ReadCompleteFlag == 3271 PH_FRINFC_MIFARESTD_FLAG0)) || 3272 (NdefMap->StdMifareContainer.ReadCompleteFlag == 3273 PH_FRINFC_MIFARESTD_FLAG1)) 3274 ? PH_FRINFC_MIFARESTD_FLAG1 3275 : PH_FRINFC_MIFARESTD_FLAG0); 3276 3277 NdefMap->StdMifareContainer.ReadCompleteFlag = (uint8_t)( 3278 (((((uint16_t)(NdefMap->StdMifareContainer.currentBlock + 3279 PH_FRINFC_MIFARESTD_VAL4) >= 3280 PH_FRINFC_MIFARESTD4K_MAX_BLK) && 3281 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD)) && 3282 (NdefMap->StdMifareContainer.ReadCompleteFlag == 3283 PH_FRINFC_MIFARESTD_FLAG0)) || 3284 (NdefMap->StdMifareContainer.ReadCompleteFlag == 3285 PH_FRINFC_MIFARESTD_FLAG1)) 3286 ? PH_FRINFC_MIFARESTD_FLAG1 3287 : PH_FRINFC_MIFARESTD_FLAG0); 3288 3289 NdefMap->StdMifareContainer.currentBlock = 3290 ((NdefMap->StdMifareContainer.ReadCompleteFlag == 3291 PH_FRINFC_MIFARESTD_FLAG1) 3292 ? PH_FRINFC_MIFARESTD_BLK4 3293 : NdefMap->StdMifareContainer.currentBlock); 3294 3295 Result = ((NdefMap->StdMifareContainer.ReadCompleteFlag == 3296 PH_FRINFC_MIFARESTD_FLAG1) 3297 ? phFriNfc_MifStd_H_BlkChk(NdefMap) 3298 : Result); 3299 } 3300 } 3301 3302 Result = 3303 ((Result != NFCSTATUS_SUCCESS) ? Result 3304 : phFriNfc_MifStd_H_ChkRdWr(NdefMap)); 3305 } else { 3306 NdefMap->StdMifareContainer.ChkNdefFlag = PH_FRINFC_MIFARESTD_FLAG0; 3307 /* Here its required to read the entire card to know the */ 3308 /* Get exact ndef size of the card */ 3309 Result = phFriNfc_MifStd_H_ChkTLVs(NdefMap, &CRFlag); 3310 } 3311 } else { 3312 /* Since we have decided temporarily not to go 3313 for any new error codes we are using 3314 NFCSTATUS_INVALID_PARAMETER even though it is not 3315 the relevant error code here TBD */ 3316 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 3317 } 3318 3319 return Result; 3320 } 3321 3322 /****************************************************************************** 3323 * Function phFriNfc_MifStd_H_GPBChk 3324 * 3325 * Description This function is checks the GPB bytes. 3326 * 3327 * Returns This function return NFCSTATUS_SUCCESS in case of success 3328 * In case of failure returns other failure value. 3329 * 3330 ******************************************************************************/ 3331 static NFCSTATUS phFriNfc_MifStd_H_GPBChk(phFriNfc_NdefMap_t* NdefMap) { 3332 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3333 3334 /* Spec version needs to be checked every time (Version check is not enabled) 3335 */ 3336 /* Result = phFriNfc_MapTool_ChkSpcVer(NdefMap, PH_FRINFC_MIFARESTD_VAL9); */ 3337 3338 /* Check rhe read and write access field 3339 in GPB is 00b 3340 bit 0 and 1 for write access check 3341 bit 2 and 3 for read access check */ 3342 if (Result == NFCSTATUS_SUCCESS) { 3343 if (((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL9] & 3344 PH_FRINFC_MIFARESTD_MASK_GPB_WR) == 3345 PH_FRINFC_MIFARESTD_GPB_RD_WR_VAL) && 3346 ((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL9] & 3347 PH_FRINFC_MIFARESTD_MASK_GPB_RD) == 3348 PH_FRINFC_MIFARESTD_GPB_RD_WR_VAL)) { 3349 NdefMap->CardState = (((NdefMap->StdMifareContainer.ChkNdefFlag == 3350 PH_FRINFC_MIFARESTD_FLAG1) || 3351 (NdefMap->StdMifareContainer.ReadNdefFlag == 3352 PH_FRINFC_MIFARESTD_FLAG1) || 3353 (NdefMap->StdMifareContainer.WrNdefFlag == 3354 PH_FRINFC_MIFARESTD_FLAG1)) 3355 ? PH_NDEFMAP_CARD_STATE_INITIALIZED 3356 : PH_NDEFMAP_CARD_STATE_READ_WRITE); 3357 } else if (((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL9] & 3358 PH_FRINFC_MIFARESTD_MASK_GPB_WR) != 3359 PH_FRINFC_MIFARESTD_GPB_RD_WR_VAL) && 3360 ((NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL9] & 3361 PH_FRINFC_MIFARESTD_MASK_GPB_RD) == 3362 PH_FRINFC_MIFARESTD_GPB_RD_WR_VAL)) { 3363 /* write access not given 3364 only read access check */ 3365 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY; 3366 } else { 3367 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID; 3368 } 3369 } 3370 3371 return Result; 3372 } 3373 3374 /****************************************************************************** 3375 * Function phFriNfc_MifStd_H_ProStatNotValid 3376 * 3377 * Description This function checks for the different status value in the 3378 * process because of proprietary forum sector. 3379 * 3380 * Returns This function return NFCSTATUS_SUCCESS in case of success 3381 * In case of failure returns other failure value. 3382 * 3383 ******************************************************************************/ 3384 static NFCSTATUS phFriNfc_MifStd_H_ProStatNotValid(phFriNfc_NdefMap_t* NdefMap, 3385 NFCSTATUS status) { 3386 NFCSTATUS Result = status; 3387 3388 /* if NFC forum sector is not found before the proprietary one then 3389 authenticate the next sector 3390 Else it is a error*/ 3391 if (NdefMap->StdMifareContainer.NFCforumSectFlag == 3392 PH_FRINFC_MIFARESTD_FLAG0) { 3393 NdefMap->StdMifareContainer.ProprforumSectFlag = 3394 PH_FRINFC_MIFARESTD_PROP_3RD_CONFIG; 3395 if (NdefMap->StdMifareContainer.currentBlock < 3396 PH_FRINFC_MIFARESTD4K_BLK128) { 3397 /* Fix for the disovery problem, 3398 if 1st sector is invalid then ignore the remaining sectors and 3399 send an error if the card is mifare 1k, 3400 if the card is mifare 4k, then update the block number to 67 and 3401 continue. 3402 Even if the authentication of that block fails then send error */ 3403 if (((NdefMap->StdMifareContainer.currentBlock < 3404 PH_FRINFC_MIFARESTD_BLK4) && 3405 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD)) || 3406 ((NdefMap->StdMifareContainer.currentBlock <= 3407 PH_FRINFC_MIFARESTD_MAD_BLK67) && 3408 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD || 3409 NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD))) { 3410 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT); 3411 } else if ((NdefMap->StdMifareContainer.currentBlock < 3412 PH_FRINFC_MIFARESTD_BLK4) && 3413 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD || 3414 NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD)) { 3415 Result = NFCSTATUS_SUCCESS; 3416 NdefMap->StdMifareContainer.currentBlock = 3417 PH_FRINFC_MIFARESTD_MAD_BLK67; 3418 } else if (((NdefMap->StdMifareContainer.currentBlock + 3419 PH_FRINFC_MIFARESTD_BLK4) > PH_FRINFC_MIFARESTD1K_MAX_BLK) && 3420 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD)) { 3421 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT); 3422 } else { 3423 NdefMap->StdMifareContainer.remainingSize -= 3424 (PH_FRINFC_MIFARESTD_MAD_BLK3 * PH_FRINFC_MIFARESTD_BLOCK_BYTES); 3425 NdefMap->StdMifareContainer.currentBlock += PH_FRINFC_MIFARESTD_BLK4; 3426 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3427 } 3428 } else if ((NdefMap->StdMifareContainer.currentBlock + 3429 PH_FRINFC_MIFARESTD_BLK15) > PH_FRINFC_MIFARESTD4K_MAX_BLK) { 3430 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT); 3431 } else { 3432 NdefMap->StdMifareContainer.remainingSize -= 3433 (PH_FRINFC_MIFARESTD_BLK15 * PH_FRINFC_MIFARESTD_BLOCK_BYTES); 3434 NdefMap->StdMifareContainer.currentBlock += 3435 PH_FRINFC_MIFARESTD_BLOCK_BYTES; 3436 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3437 } 3438 Result = 3439 ((Result != NFCSTATUS_SUCCESS) 3440 ? (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT)) 3441 : phFriNfc_MifStd_H_AuthSector(NdefMap)); 3442 } else if ((NdefMap->StdMifareContainer.ProprforumSectFlag == 3443 PH_FRINFC_MIFARESTD_PROP_3RD_CONFIG) && 3444 (NdefMap->StdMifareContainer.NFCforumSectFlag == 3445 PH_FRINFC_MIFARESTD_FLAG1)) { 3446 /* if the proprietary forum sector are found before 3447 NFC forum sector then again a proprietary 3448 forum sector are found after the NFC forum 3449 sector */ 3450 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT); 3451 } else { 3452 NdefMap->StdMifareContainer.ProprforumSectFlag = 3453 PH_FRINFC_MIFARESTD_PROP_2ND_CONFIG; 3454 switch (NdefMap->PrevOperation) { 3455 case PH_FRINFC_NDEFMAP_CHECK_OPE: 3456 case PH_FRINFC_NDEFMAP_GET_ACTSIZE_OPE: 3457 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT); 3458 break; 3459 3460 case PH_FRINFC_NDEFMAP_READ_OPE: 3461 if ((NdefMap->TLVStruct.NdefTLVFoundFlag == 3462 PH_FRINFC_MIFARESTD_FLAG1) && 3463 (NdefMap->TLVStruct.NoLbytesinTLV == PH_FRINFC_MIFARESTD_VAL0)) { 3464 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; 3465 Result = NFCSTATUS_SUCCESS; 3466 } else { 3467 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT); 3468 } 3469 break; 3470 3471 case PH_FRINFC_NDEFMAP_WRITE_OPE: 3472 default: 3473 /* This means the further write is not possible, 3474 EOF_NDEF_CONTAINER_REACHED */ 3475 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 3476 PH_FRINFC_MIFARESTD_FLAG1; 3477 /* Write the length to the L field in the TLV */ 3478 NdefMap->StdMifareContainer.TempBlockNo = 3479 NdefMap->StdMifareContainer.currentBlock; 3480 phFriNfc_MifStd_H_SetNdefBlkAuth(NdefMap); 3481 NdefMap->StdMifareContainer.currentBlock = 3482 NdefMap->TLVStruct.NdefTLVBlock; 3483 Result = phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap); 3484 break; 3485 } 3486 } 3487 3488 return Result; 3489 } 3490 3491 /****************************************************************************** 3492 * Function phFriNfc_MifStd_H_RdBeforeWr 3493 * 3494 * Description This function is used to read the NDEF TLV block. 3495 * 3496 * Returns This function return NFCSTATUS_SUCCESS in case of success 3497 * In case of failure returns other failure value. 3498 * 3499 ******************************************************************************/ 3500 static NFCSTATUS phFriNfc_MifStd_H_RdBeforeWr(phFriNfc_NdefMap_t* NdefMap) { 3501 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3502 3503 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RD_BEF_WR; 3504 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE; 3505 3506 Result = phFriNfc_MifStd_H_Rd16Bytes( 3507 NdefMap, NdefMap->StdMifareContainer.currentBlock); 3508 3509 return Result; 3510 } 3511 3512 /****************************************************************************** 3513 * Function phFriNfc_MifStd_H_ProBytesToWr 3514 * 3515 * Description This function processes the NDEF TLV block read bytes to 3516 * start write from the NDEF TLV. 3517 * 3518 * Returns This function return NFCSTATUS_SUCCESS in case of success 3519 * In case of failure returns other failure value. 3520 * 3521 ******************************************************************************/ 3522 static NFCSTATUS phFriNfc_MifStd_H_ProBytesToWr(phFriNfc_NdefMap_t* NdefMap) { 3523 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3524 uint8_t TempLength = PH_FRINFC_MIFARESTD_VAL0; 3525 3526 if (*NdefMap->SendRecvLength == PH_FRINFC_MIFARESTD_BYTES_READ) { 3527 memcpy(&NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL1], 3528 NdefMap->SendRecvBuf, PH_FRINFC_MIFARESTD_BLOCK_BYTES); 3529 3530 /* Write to Ndef TLV Block */ 3531 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3532 NdefMap->StdMifareContainer.currentBlock; 3533 3534 TempLength = ((NdefMap->StdMifareContainer.currentBlock == 3535 NdefMap->TLVStruct.NdefTLVBlock) 3536 ? phFriNfc_MifStd_H_UpdateTLV(NdefMap) 3537 : phFriNfc_MifStd_H_UpdRemTLV(NdefMap)); 3538 3539 NdefMap->StdMifareContainer.remainingSize -= 3540 ((NdefMap->StdMifareContainer.remSizeUpdFlag == 3541 PH_FRINFC_MIFARESTD_FLAG1) 3542 ? PH_FRINFC_MIFARESTD_VAL2 3543 : PH_FRINFC_MIFARESTD_VAL0); 3544 3545 NdefMap->StdMifareContainer.remSizeUpdFlag = PH_FRINFC_MIFARESTD_FLAG0; 3546 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_WR_TLV; 3547 Result = ((TempLength == PH_FRINFC_MIFARESTD_BLOCK_BYTES) 3548 ? phFriNfc_MifStd_H_WrTLV(NdefMap) 3549 : phFriNfc_MifStd_H_fillSendBuf(NdefMap, TempLength)); 3550 } else { 3551 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_READ_FAILED); 3552 } 3553 3554 return Result; 3555 } 3556 3557 /****************************************************************************** 3558 * Function phFriNfc_MifStd_H_UpdateTLV 3559 * 3560 * Description This function writes ndef to add the TLV structure. 3561 * 3562 * Returns uint8_t TempLength 3563 * 3564 ******************************************************************************/ 3565 static uint8_t phFriNfc_MifStd_H_UpdateTLV(phFriNfc_NdefMap_t* NdefMap) { 3566 uint8_t TempLength = PH_FRINFC_MIFARESTD_VAL0; 3567 3568 TempLength = 3569 (uint8_t)(NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_MIFARESTD_VAL1); 3570 /* Creating TLV */ 3571 if (NdefMap->TLVStruct.NULLTLVCount >= 2) { 3572 if ((PH_FRINFC_MIFARESTD_BYTES_READ - TempLength) == 3573 PH_FRINFC_MIFARESTD_VAL0) { 3574 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 3575 } else { 3576 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 3577 TempLength++; 3578 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L0; 3579 } 3580 } else { 3581 switch ((PH_FRINFC_MIFARESTD_BYTES_READ - TempLength)) { 3582 case PH_FRINFC_MIFARESTD_VAL0: 3583 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 3584 break; 3585 3586 case PH_FRINFC_MIFARESTD_VAL1: 3587 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 3588 TempLength++; 3589 NdefMap->TLVStruct.prevLenByteValue = (uint16_t)( 3590 (NdefMap->SendRecvBuf[TempLength] >= PH_FRINFC_MIFARESTD_NDEFTLV_L) 3591 ? PH_FRINFC_MIFARESTD_VAL0 3592 : NdefMap->SendRecvBuf[TempLength]); 3593 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 3594 break; 3595 3596 case PH_FRINFC_MIFARESTD_VAL2: 3597 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 3598 TempLength++; 3599 NdefMap->TLVStruct.prevLenByteValue = (uint16_t)( 3600 (NdefMap->SendRecvBuf[TempLength] >= PH_FRINFC_MIFARESTD_NDEFTLV_L) 3601 ? NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)] 3602 : NdefMap->SendRecvBuf[TempLength]); 3603 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 3604 TempLength++; 3605 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 3606 break; 3607 3608 default: 3609 NdefMap->TLVStruct.prevLenByteValue = NdefMap->SendRecvBuf[TempLength]; 3610 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 3611 TempLength++; 3612 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 3613 TempLength++; 3614 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 3615 TempLength++; 3616 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L0; 3617 break; 3618 } 3619 } 3620 3621 return TempLength; 3622 } 3623 3624 /****************************************************************************** 3625 * Function phFriNfc_MifStd_H_fillSendBuf 3626 * 3627 * Description It fill the send buffer to write. 3628 * 3629 * Returns This function return NFCSTATUS_SUCCESS in case of success 3630 * In case of failure returns other failure value. 3631 * 3632 ******************************************************************************/ 3633 static NFCSTATUS phFriNfc_MifStd_H_fillSendBuf(phFriNfc_NdefMap_t* NdefMap, 3634 uint8_t Length) { 3635 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3636 uint16_t RemainingBytes = PH_FRINFC_MIFARESTD_VAL0, 3637 BytesToWrite = PH_FRINFC_MIFARESTD_VAL0; 3638 uint8_t index = PH_FRINFC_MIFARESTD_VAL0; 3639 3640 Length = (Length + PH_FRINFC_MIFARESTD_VAL1); 3641 3642 RemainingBytes = 3643 (uint16_t)((NdefMap->StdMifareContainer.remainingSize < 3644 (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)) 3645 ? NdefMap->StdMifareContainer.remainingSize 3646 : (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)); 3647 3648 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 3649 NdefMap->StdMifareContainer.currentBlock; 3650 /* Get the number of bytes that can be written after copying 3651 the internal buffer */ 3652 BytesToWrite = 3653 ((RemainingBytes < ((PH_FRINFC_MIFARESTD_WR_A_BLK - Length) - 3654 NdefMap->StdMifareContainer.internalLength)) 3655 ? RemainingBytes 3656 : ((PH_FRINFC_MIFARESTD_WR_A_BLK - Length) - 3657 NdefMap->StdMifareContainer.internalLength)); 3658 3659 if (NdefMap->StdMifareContainer.internalLength > PH_FRINFC_MIFARESTD_VAL0) { 3660 /* copy the internal buffer to the send buffer */ 3661 memcpy(&(NdefMap->SendRecvBuf[Length]), 3662 NdefMap->StdMifareContainer.internalBuf, 3663 NdefMap->StdMifareContainer.internalLength); 3664 } 3665 3666 /* Copy Bytes to write in the send buffer */ 3667 memcpy(&(NdefMap->SendRecvBuf[(Length + 3668 NdefMap->StdMifareContainer.internalLength)]), 3669 &(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]), BytesToWrite); 3670 3671 /* update number of bytes written from the user buffer */ 3672 NdefMap->NumOfBytesWritten = BytesToWrite; 3673 3674 /* check the exact number of bytes written to a block including the 3675 internal length */ 3676 *NdefMap->DataCount = 3677 ((BytesToWrite + NdefMap->StdMifareContainer.internalLength + Length) - 3678 PH_FRINFC_MIFARESTD_VAL1); 3679 3680 /* if total bytes to write in the card is less than 4 bytes then 3681 pad zeroes till 4 bytes */ 3682 if ((BytesToWrite + NdefMap->StdMifareContainer.internalLength + Length) < 3683 PH_FRINFC_MIFARESTD_WR_A_BLK) { 3684 for (index = (uint8_t)(BytesToWrite + 3685 NdefMap->StdMifareContainer.internalLength + Length); 3686 index < PH_FRINFC_MIFARESTD_WR_A_BLK; index++) { 3687 NdefMap->SendRecvBuf[index] = 3688 (uint8_t)((index == (BytesToWrite + Length + 3689 NdefMap->StdMifareContainer.internalLength)) 3690 ? PH_FRINFC_MIFARESTD_TERMTLV_T 3691 : PH_FRINFC_MIFARESTD_NULLTLV_T); 3692 3693 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 3694 } 3695 } 3696 3697 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_MIFARESTD_FLAG1; 3698 3699 /* A temporary buffer to hold four bytes of data that is 3700 written to the card */ 3701 memcpy(NdefMap->StdMifareContainer.Buffer, 3702 &(NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL1]), 3703 PH_FRINFC_MIFARESTD_BLOCK_BYTES); 3704 3705 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_WR_TLV; 3706 Result = phFriNfc_MifStd_H_WrTLV(NdefMap); 3707 3708 return Result; 3709 } 3710 3711 /****************************************************************************** 3712 * Function phFriNfc_MifStd_H_WrTLV 3713 * 3714 * Description This function writes 16 bytes in a block. 3715 * 3716 * Returns This function return NFCSTATUS_SUCCESS in case of success 3717 * In case of failure returns other failure value. 3718 * 3719 ******************************************************************************/ 3720 static NFCSTATUS phFriNfc_MifStd_H_WrTLV(phFriNfc_NdefMap_t* NdefMap) { 3721 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3722 3723 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 3724 NdefMap->MapCompletionInfo.Context = NdefMap; 3725 /* Write from here */ 3726 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_WRITE; 3727 3728 NdefMap->Cmd.MfCmd = phHal_eMifareWrite16; 3729 3730 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 3731 3732 /* Call the Overlapped HAL Transceive function */ 3733 Result = phFriNfc_ExtnsTransceive(NdefMap->pTransceiveInfo, NdefMap->Cmd, 3734 NdefMap->SendRecvBuf, NdefMap->SendLength, 3735 NdefMap->SendRecvLength); 3736 3737 return Result; 3738 } 3739 3740 /****************************************************************************** 3741 * Function phFriNfc_MifStd_H_ProWrTLV 3742 * 3743 * Description This function processes the write TLV bytes in a block. 3744 * 3745 * Returns This function return NFCSTATUS_SUCESS in case of success 3746 * In case of failure returns other failure value. 3747 * 3748 ******************************************************************************/ 3749 static NFCSTATUS phFriNfc_MifStd_H_ProWrTLV(phFriNfc_NdefMap_t* NdefMap) { 3750 NFCSTATUS Result = NFCSTATUS_SUCCESS; 3751 3752 /* Check that if complete TLV has been written in the 3753 card if yes enter the below check or go to else*/ 3754 if (((((PH_FRINFC_MIFARESTD_BLOCK_BYTES - NdefMap->TLVStruct.NdefTLVByte) == 3755 PH_FRINFC_MIFARESTD_VAL1) && 3756 (NdefMap->TLVStruct.NULLTLVCount >= PH_FRINFC_MIFARESTD_VAL2)) || 3757 (((PH_FRINFC_MIFARESTD_BLOCK_BYTES - NdefMap->TLVStruct.NdefTLVByte) <= 3758 PH_FRINFC_MIFARESTD_VAL3) && 3759 (NdefMap->TLVStruct.NULLTLVCount == PH_FRINFC_MIFARESTD_VAL0))) && 3760 (NdefMap->StdMifareContainer.currentBlock == 3761 NdefMap->TLVStruct.NdefTLVBlock)) { 3762 /* increment the block and chekc the block is in the same sector 3763 using the block check function */ 3764 NdefMap->StdMifareContainer.RdBeforeWrFlag = PH_FRINFC_MIFARESTD_FLAG1; 3765 NdefMap->StdMifareContainer.currentBlock++; 3766 NdefMap->StdMifareContainer.NdefBlocks++; 3767 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3768 if (Result == NFCSTATUS_SUCCESS) { 3769 Result = 3770 ((NdefMap->StdMifareContainer.AuthDone == PH_FRINFC_MIFARESTD_FLAG0) 3771 ? phFriNfc_MifStd_H_AuthSector(NdefMap) 3772 : phFriNfc_MifStd_H_RdBeforeWr(NdefMap)); 3773 } 3774 } else { 3775 NdefMap->StdMifareContainer.RdBeforeWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 3776 if (NdefMap->ApduBuffIndex < (uint16_t)NdefMap->ApduBufferSize) { 3777 if (*NdefMap->DataCount < PH_FRINFC_MIFARESTD_BLOCK_BYTES) { 3778 /* Write complete, so next byte shall be */ 3779 NdefMap->StdMifareContainer.internalLength = *NdefMap->DataCount; 3780 3781 /* Copy bytes less than 16 to internal buffer 3782 for the next write this can be used */ 3783 memcpy(NdefMap->StdMifareContainer.internalBuf, 3784 NdefMap->StdMifareContainer.Buffer, 3785 NdefMap->StdMifareContainer.internalLength); 3786 } 3787 3788 /* Increment the Send Buffer index */ 3789 NdefMap->ApduBuffIndex += NdefMap->NumOfBytesWritten; 3790 3791 NdefMap->StdMifareContainer.remainingSize -= NdefMap->NumOfBytesWritten; 3792 3793 /* Check for the End of Card */ 3794 if ((NdefMap->StdMifareContainer.remainingSize == 3795 PH_FRINFC_MIFARESTD_VAL0) || 3796 (NdefMap->ApduBuffIndex == NdefMap->ApduBufferSize)) { 3797 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 3798 (uint8_t)((NdefMap->StdMifareContainer.remainingSize == 0) 3799 ? PH_FRINFC_MIFARESTD_FLAG1 3800 : PH_FRINFC_MIFARESTD_FLAG0); 3801 3802 if (NdefMap->StdMifareContainer.internalLength == 3803 PH_FRINFC_MIFARESTD_VAL0) { 3804 NdefMap->StdMifareContainer.currentBlock++; 3805 /* Mifare 4k Card, After 128th Block 3806 each sector = 16 blocks in Mifare 4k */ 3807 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3808 NdefMap->StdMifareContainer.NdefBlocks++; 3809 } 3810 3811 NdefMap->TLVStruct.SetTermTLVFlag = (uint8_t)( 3812 ((NdefMap->StdMifareContainer.remainingSize == 3813 PH_FRINFC_MIFARESTD_VAL0) || 3814 (NdefMap->TLVStruct.SetTermTLVFlag == PH_FRINFC_MIFARESTD_FLAG1)) 3815 ? PH_FRINFC_MIFARESTD_FLAG1 3816 : PH_FRINFC_MIFARESTD_FLAG0); 3817 3818 } else { 3819 NdefMap->StdMifareContainer.currentBlock++; 3820 /* Mifare 4k Card, After 128th Block 3821 each sector = 16 blocks in Mifare 4k */ 3822 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 3823 if (Result == NFCSTATUS_SUCCESS) { 3824 NdefMap->StdMifareContainer.NdefBlocks++; 3825 Result = ((NdefMap->StdMifareContainer.AuthDone == 3826 PH_FRINFC_MIFARESTD_FLAG1) 3827 ? phFriNfc_MifStd_H_WrABlock(NdefMap) 3828 : phFriNfc_MifStd_H_AuthSector(NdefMap)); 3829 } 3830 } 3831 } 3832 } 3833 3834 if ((Result == NFCSTATUS_SUCCESS) && 3835 (NdefMap->TLVStruct.SetTermTLVFlag != PH_FRINFC_MIFARESTD_FLAG1) && 3836 (NdefMap->StdMifareContainer.remainingSize > PH_FRINFC_MIFARESTD_VAL0)) { 3837 Result = phFriNfc_MifStd_H_WrTermTLV(NdefMap); 3838 } else { 3839 if ((Result == NFCSTATUS_SUCCESS) && 3840 (NdefMap->TLVStruct.SetTermTLVFlag == PH_FRINFC_MIFARESTD_FLAG1)) { 3841 /* Write the length to the L field in the TLV */ 3842 NdefMap->StdMifareContainer.TempBlockNo = 3843 NdefMap->StdMifareContainer.currentBlock; 3844 phFriNfc_MifStd_H_SetNdefBlkAuth(NdefMap); 3845 NdefMap->StdMifareContainer.currentBlock = 3846 NdefMap->TLVStruct.NdefTLVBlock; 3847 Result = phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap); 3848 } 3849 } 3850 3851 return Result; 3852 } 3853 3854 /****************************************************************************** 3855 * Function phFriNfc_MifStd_H_UpdRemTLV 3856 * 3857 * Description This function updates the remaining TLV. 3858 * 3859 * Returns uint8_t TempLength : length value 3860 * 3861 ******************************************************************************/ 3862 static uint8_t phFriNfc_MifStd_H_UpdRemTLV(phFriNfc_NdefMap_t* NdefMap) { 3863 uint8_t TempLength = PH_FRINFC_MIFARESTD_VAL1; 3864 3865 if (NdefMap->TLVStruct.NULLTLVCount >= PH_FRINFC_MIFARESTD_VAL2) { 3866 NdefMap->TLVStruct.prevLenByteValue = NdefMap->SendRecvBuf[TempLength]; 3867 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L0; 3868 } else { 3869 switch ( 3870 (PH_FRINFC_MIFARESTD_BLOCK_BYTES - NdefMap->TLVStruct.NdefTLVByte)) { 3871 case PH_FRINFC_MIFARESTD_VAL1: 3872 NdefMap->TLVStruct.prevLenByteValue = 3873 (((NdefMap->SendRecvBuf[TempLength] == 3874 PH_FRINFC_MIFARESTD_NDEFTLV_L)) 3875 ? (((uint16_t)NdefMap 3876 ->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)] 3877 << PH_FRINFC_MIFARESTD_LEFTSHIFT8) + 3878 NdefMap 3879 ->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL2)]) 3880 : NdefMap->SendRecvBuf[TempLength]); 3881 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 3882 TempLength++; 3883 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 3884 TempLength++; 3885 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L0; 3886 break; 3887 3888 case PH_FRINFC_MIFARESTD_VAL2: 3889 NdefMap->TLVStruct.prevLenByteValue = 3890 (((NdefMap->SendRecvBuf[TempLength] == 3891 PH_FRINFC_MIFARESTD_NDEFTLV_L)) 3892 ? (((uint16_t)NdefMap->SendRecvBuf[TempLength] 3893 << PH_FRINFC_MIFARESTD_LEFTSHIFT8) + 3894 NdefMap 3895 ->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)]) 3896 : NdefMap->SendRecvBuf[TempLength]); 3897 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 3898 TempLength++; 3899 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L0; 3900 break; 3901 3902 case PH_FRINFC_MIFARESTD_VAL3: 3903 default: 3904 NdefMap->TLVStruct.prevLenByteValue = 3905 ((NdefMap->TLVStruct.prevLenByteValue 3906 << PH_FRINFC_MIFARESTD_LEFTSHIFT8) + 3907 NdefMap->SendRecvBuf[TempLength]); 3908 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L0; 3909 break; 3910 } 3911 } 3912 3913 return TempLength; 3914 } 3915 3916 /****************************************************************************** 3917 * Function phFriNfc_MifStd_H_fillTLV1 3918 * 3919 * Description This function updates the length field if more than one 3920 * NULL TLVs exists before of the NDEF TLV. 3921 * 3922 * Returns void 3923 * 3924 ******************************************************************************/ 3925 static void phFriNfc_MifStd_H_fillTLV1(phFriNfc_NdefMap_t* NdefMap) { 3926 uint8_t TempLength = 3927 (uint8_t)(NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_MIFARESTD_VAL1); 3928 3929 NdefMap->TLVStruct.prevLenByteValue = 3930 ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) 3931 ? (NdefMap->TLVStruct.prevLenByteValue + NdefMap->ApduBuffIndex) 3932 : NdefMap->ApduBuffIndex); 3933 3934 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG1; 3935 switch (NdefMap->TLVStruct.NdefTLVByte) { 3936 case PH_FRINFC_MIFARESTD_VAL0: 3937 if (NdefMap->TLVStruct.prevLenByteValue >= 3938 PH_FRINFC_MIFARESTD_NDEFTLV_L) { 3939 NdefMap->SendRecvBuf[TempLength] = 3940 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 3941 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 3942 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)] = 3943 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 3944 } else { 3945 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 3946 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)] = 3947 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 3948 3949 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 3950 } 3951 break; 3952 3953 case PH_FRINFC_MIFARESTD_VAL1: 3954 if (NdefMap->TLVStruct.prevLenByteValue >= 3955 PH_FRINFC_MIFARESTD_NDEFTLV_L) { 3956 NdefMap->SendRecvBuf[TempLength - PH_FRINFC_MIFARESTD_VAL1] = 3957 PH_FRINFC_MIFARESTD_NDEFTLV_L; 3958 NdefMap->SendRecvBuf[TempLength] = 3959 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 3960 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 3961 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)] = 3962 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 3963 } else { 3964 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 3965 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)] = 3966 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 3967 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 3968 } 3969 break; 3970 3971 case PH_FRINFC_MIFARESTD_VAL15: 3972 /* if "Type" of TLV present at byte 15 */ 3973 if (NdefMap->TLVStruct.prevLenByteValue >= 3974 PH_FRINFC_MIFARESTD_NDEFTLV_L) { 3975 /* Update the null TLV, ndef TLV block and ndef TLV byte */ 3976 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 3977 NdefMap->TLVStruct.NdefTLVBlock = 3978 NdefMap->StdMifareContainer.currentBlock; 3979 NdefMap->TLVStruct.NdefTLVByte = 3980 (TempLength - PH_FRINFC_MIFARESTD_VAL3); 3981 3982 NdefMap->SendRecvBuf[(TempLength - PH_FRINFC_MIFARESTD_VAL2)] = 3983 PH_FRINFC_MIFARESTD_NDEFTLV_T; 3984 NdefMap->SendRecvBuf[(TempLength - PH_FRINFC_MIFARESTD_VAL1)] = 3985 PH_FRINFC_MIFARESTD_NDEFTLV_L; 3986 NdefMap->SendRecvBuf[TempLength] = 3987 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 3988 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 3989 } else { 3990 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 3991 } 3992 break; 3993 3994 default: 3995 /* Already the TLV is present so just append the length field */ 3996 if (NdefMap->TLVStruct.prevLenByteValue >= 3997 PH_FRINFC_MIFARESTD_NDEFTLV_L) { 3998 /* Update the null TLV, ndef TLV block and ndef TLV byte */ 3999 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 4000 NdefMap->TLVStruct.NdefTLVBlock = 4001 NdefMap->StdMifareContainer.currentBlock; 4002 NdefMap->TLVStruct.NdefTLVByte = 4003 (TempLength - PH_FRINFC_MIFARESTD_VAL3); 4004 4005 NdefMap->SendRecvBuf[(TempLength - PH_FRINFC_MIFARESTD_VAL2)] = 4006 (uint8_t)PH_FRINFC_MIFARESTD_NDEFTLV_T; 4007 NdefMap->SendRecvBuf[(TempLength - PH_FRINFC_MIFARESTD_VAL1)] = 4008 (uint8_t)PH_FRINFC_MIFARESTD_NDEFTLV_L; 4009 NdefMap->SendRecvBuf[TempLength] = 4010 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 4011 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 4012 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)] = 4013 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 4014 } else { 4015 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4016 NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_MIFARESTD_VAL1)] = 4017 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 4018 } 4019 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 4020 break; 4021 } 4022 4023 return; 4024 } 4025 4026 /****************************************************************************** 4027 * Function phFriNfc_MifStd_H_fillTLV2 4028 * 4029 * Description This function is updates the length field if more than one 4030 * NULL TLVs does not exists before the TLV. 4031 * 4032 * Returns void 4033 * 4034 ******************************************************************************/ 4035 static void phFriNfc_MifStd_H_fillTLV2(phFriNfc_NdefMap_t* NdefMap) { 4036 uint8_t TempLength = 4037 (uint8_t)(NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_MIFARESTD_VAL1); 4038 4039 NdefMap->TLVStruct.prevLenByteValue = 4040 ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) 4041 ? (NdefMap->TLVStruct.prevLenByteValue + NdefMap->ApduBuffIndex) 4042 : NdefMap->ApduBuffIndex); 4043 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG1; 4044 switch (NdefMap->TLVStruct.NdefTLVByte) { 4045 case PH_FRINFC_MIFARESTD_VAL13: 4046 if (NdefMap->TLVStruct.prevLenByteValue >= 4047 PH_FRINFC_MIFARESTD_NDEFTLV_L) { 4048 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4049 TempLength++; 4050 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L; 4051 TempLength++; 4052 NdefMap->SendRecvBuf[TempLength] = 4053 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 4054 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 4055 } else { 4056 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4057 TempLength++; 4058 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4059 TempLength++; 4060 4061 /* Update the null TLV, ndef TLV block and ndef TLV byte */ 4062 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL2; 4063 NdefMap->TLVStruct.NdefTLVBlock = 4064 NdefMap->StdMifareContainer.currentBlock; 4065 NdefMap->TLVStruct.NdefTLVByte = 4066 (TempLength - PH_FRINFC_MIFARESTD_VAL1); 4067 4068 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4069 } 4070 break; 4071 4072 case PH_FRINFC_MIFARESTD_VAL14: 4073 if (NdefMap->TLVStruct.prevLenByteValue >= 4074 PH_FRINFC_MIFARESTD_NDEFTLV_L) { 4075 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4076 TempLength++; 4077 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L; 4078 } else { 4079 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4080 TempLength++; 4081 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4082 } 4083 break; 4084 4085 case PH_FRINFC_MIFARESTD_VAL15: 4086 if (NdefMap->TLVStruct.prevLenByteValue >= 4087 PH_FRINFC_MIFARESTD_NDEFTLV_L) { 4088 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4089 } else { 4090 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4091 } 4092 break; 4093 4094 default: 4095 if (NdefMap->TLVStruct.prevLenByteValue >= 4096 PH_FRINFC_MIFARESTD_NDEFTLV_L) { 4097 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4098 TempLength++; 4099 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L; 4100 TempLength++; 4101 NdefMap->SendRecvBuf[TempLength] = 4102 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 4103 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 4104 TempLength++; 4105 NdefMap->SendRecvBuf[TempLength] = 4106 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 4107 } else { 4108 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4109 TempLength++; 4110 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4111 TempLength++; 4112 4113 /* Update the null TLV, ndef TLV block and ndef TLV byte */ 4114 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL2; 4115 NdefMap->TLVStruct.NdefTLVBlock = 4116 NdefMap->StdMifareContainer.currentBlock; 4117 NdefMap->TLVStruct.NdefTLVByte = 4118 (TempLength - PH_FRINFC_MIFARESTD_VAL1); 4119 4120 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4121 TempLength++; 4122 NdefMap->SendRecvBuf[TempLength] = 4123 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 4124 } 4125 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 4126 break; 4127 } 4128 4129 return; 4130 } 4131 4132 /****************************************************************************** 4133 * Function phFriNfc_MifStd_H_CallWrNdefLen 4134 * 4135 * Description This function is used to increment/decrement the ndef tlv 4136 *block and read the block. 4137 * 4138 * Returns This function return NFCSTATUS_SUCCESS in case of success 4139 * In case of failure returns other failure value. 4140 * 4141 ******************************************************************************/ 4142 static NFCSTATUS phFriNfc_MifStd_H_CallWrNdefLen(phFriNfc_NdefMap_t* NdefMap) { 4143 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4144 4145 if (NdefMap->TLVStruct.NULLTLVCount >= PH_FRINFC_MIFARESTD_VAL2) { 4146 if ((NdefMap->TLVStruct.NdefTLVByte == PH_FRINFC_MIFARESTD_VAL0) || 4147 (NdefMap->TLVStruct.NdefTLVByte == PH_FRINFC_MIFARESTD_VAL1)) { 4148 /* In this case, current block is decremented because the 4149 NULL TLVs are in the previous block */ 4150 NdefMap->StdMifareContainer.currentBlock--; 4151 Result = phFriNfc_MifStd_H_BlkChk_1(NdefMap); 4152 } else { 4153 /* case NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL15: 4154 Current block is incremented to update the remaining TLV 4155 structure */ 4156 NdefMap->StdMifareContainer.currentBlock++; 4157 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 4158 } 4159 } else { 4160 if ((NdefMap->TLVStruct.NdefTLVByte == PH_FRINFC_MIFARESTD_VAL13) || 4161 (NdefMap->TLVStruct.NdefTLVByte == PH_FRINFC_MIFARESTD_VAL14) || 4162 (NdefMap->TLVStruct.NdefTLVByte == PH_FRINFC_MIFARESTD_VAL15)) { 4163 /* Current block is incremented to update the remaining TLV 4164 structure */ 4165 NdefMap->StdMifareContainer.currentBlock++; 4166 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 4167 } 4168 } 4169 4170 Result = 4171 ((Result == NFCSTATUS_SUCCESS) ? phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap) 4172 : Result); 4173 4174 return Result; 4175 } 4176 4177 /****************************************************************************** 4178 * Function phFriNfc_MifStd_H_BlkChk_1 4179 * 4180 * Description This function check the current block is valid or not 4181 * if not valid decrement the current block till the valid 4182 *block. 4183 * 4184 * Returns This function return NFCSTATUS_SUCCESS in case of success 4185 * In case of failure returns other failure value. 4186 * 4187 ******************************************************************************/ 4188 static NFCSTATUS phFriNfc_MifStd_H_BlkChk_1(phFriNfc_NdefMap_t* NdefMap) { 4189 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4190 uint8_t SectorID = PH_FRINFC_MIFARESTD_VAL0; 4191 4192 /* Get a Sector ID for the Current Block */ 4193 SectorID = 4194 phFriNfc_MifStd_H_GetSect(NdefMap->StdMifareContainer.currentBlock); 4195 4196 /* Check the sector id is valid or not and if valid then check the 4197 current block is greater than 128 */ 4198 if ((NdefMap->StdMifareContainer.aid[SectorID] == 4199 PH_FRINFC_MIFARESTD_NDEF_COMP) && 4200 (((SectorID <= PH_FRINFC_MIFARESTD_VAL15) && 4201 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD)) || 4202 ((SectorID <= PH_FRINFC_MIFARESTD_SECTOR_NO31) && 4203 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD)) || 4204 ((SectorID <= PH_FRINFC_MIFARESTD_SECTOR_NO39) && 4205 (NdefMap->CardType == PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD)))) { 4206 if (NdefMap->StdMifareContainer.currentBlock > 128) { 4207 NdefMap->TLVStruct.NdefTLVAuthFlag = 4208 ((((NdefMap->StdMifareContainer.currentBlock + 4209 PH_FRINFC_MIFARESTD_VAL1) % 4210 PH_FRINFC_MIFARESTD_MAD_BLK16) == PH_FRINFC_MIFARESTD_VAL0) 4211 ? PH_FRINFC_MIFARESTD_FLAG1 4212 : PH_FRINFC_MIFARESTD_FLAG0); 4213 4214 NdefMap->StdMifareContainer.currentBlock -= 4215 ((((NdefMap->StdMifareContainer.currentBlock + 4216 PH_FRINFC_MIFARESTD_VAL1) % 4217 PH_FRINFC_MIFARESTD_MAD_BLK16) == PH_FRINFC_MIFARESTD_VAL0) 4218 ? PH_FRINFC_MIFARESTD_VAL1 4219 : PH_FRINFC_MIFARESTD_VAL0); 4220 4221 } else { 4222 NdefMap->TLVStruct.NdefTLVAuthFlag = 4223 ((((NdefMap->StdMifareContainer.currentBlock + 4224 PH_FRINFC_MIFARESTD_VAL1) % 4225 PH_FRINFC_MIFARESTD_BLK4) == PH_FRINFC_MIFARESTD_VAL0) 4226 ? PH_FRINFC_MIFARESTD_FLAG1 4227 : PH_FRINFC_MIFARESTD_FLAG0); 4228 4229 NdefMap->StdMifareContainer.currentBlock -= 4230 ((((NdefMap->StdMifareContainer.currentBlock + 4231 PH_FRINFC_MIFARESTD_VAL1) % 4232 PH_FRINFC_MIFARESTD_BLK4) == PH_FRINFC_MIFARESTD_VAL1) 4233 ? PH_FRINFC_MIFARESTD_VAL1 4234 : PH_FRINFC_MIFARESTD_VAL0); 4235 } 4236 } else { 4237 /*Error: No Ndef Compliant Sectors present.*/ 4238 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 4239 } 4240 4241 return Result; 4242 } 4243 4244 /****************************************************************************** 4245 * Function phFriNfc_MifStd_H_fillTLV1_1 4246 * 4247 * Description This function updates the length of the TLV if NULL TLVs 4248 * greater than or equal to 2. 4249 * 4250 * Returns void 4251 * 4252 ******************************************************************************/ 4253 static void phFriNfc_MifStd_H_fillTLV1_1(phFriNfc_NdefMap_t* NdefMap) { 4254 switch (NdefMap->TLVStruct.NdefTLVByte) { 4255 case PH_FRINFC_MIFARESTD_VAL0: 4256 /* In the first write ndef length procedure, the 4257 length is updated, in this case T and L = 0xFF of TLV are 4258 updated */ 4259 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 4260 NdefMap->TLVStruct.NdefTLVBlock = 4261 NdefMap->StdMifareContainer.currentBlock; 4262 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL14; 4263 4264 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL15] = 4265 PH_FRINFC_MIFARESTD_NDEFTLV_T; 4266 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL16] = 4267 PH_FRINFC_MIFARESTD_NDEFTLV_L; 4268 break; 4269 4270 case PH_FRINFC_MIFARESTD_VAL1: 4271 /* In the first write ndef length procedure, the 4272 length is updated, in this case T of TLV is 4273 updated */ 4274 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL0; 4275 NdefMap->TLVStruct.NdefTLVBlock = 4276 NdefMap->StdMifareContainer.currentBlock; 4277 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_MIFARESTD_VAL15; 4278 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL16] = 4279 PH_FRINFC_MIFARESTD_NDEFTLV_T; 4280 break; 4281 4282 case PH_FRINFC_MIFARESTD_VAL15: 4283 default: 4284 /* In the first ndef write length, part of the L field or only T 4285 (if update length is less than 255) is updated */ 4286 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL1] = 4287 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 4288 break; 4289 } 4290 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 4291 4292 return; 4293 } 4294 4295 /****************************************************************************** 4296 * Function phFriNfc_MifStd_H_fillTLV2_1 4297 * 4298 * Description This function updates the length of the TLV if NULL TLVs 4299 * less than 2. 4300 * 4301 * Returns void 4302 * 4303 ******************************************************************************/ 4304 static void phFriNfc_MifStd_H_fillTLV2_1(phFriNfc_NdefMap_t* NdefMap) { 4305 uint8_t TempLength = PH_FRINFC_MIFARESTD_VAL1; 4306 switch (NdefMap->TLVStruct.NdefTLVByte) { 4307 case PH_FRINFC_MIFARESTD_VAL13: 4308 /* In last write ndef length, part of length (L) field of TLV 4309 is updated now */ 4310 NdefMap->SendRecvBuf[TempLength] = 4311 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 4312 break; 4313 4314 case PH_FRINFC_MIFARESTD_VAL14: 4315 /* In last write ndef length, part of length (L) field of TLV 4316 is updated now */ 4317 if (NdefMap->TLVStruct.prevLenByteValue >= 4318 PH_FRINFC_MIFARESTD_NDEFTLV_L) { 4319 NdefMap->SendRecvBuf[TempLength] = 4320 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 4321 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 4322 TempLength++; 4323 NdefMap->SendRecvBuf[TempLength] = 4324 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 4325 } else { 4326 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL2; 4327 NdefMap->TLVStruct.NdefTLVBlock = 4328 NdefMap->StdMifareContainer.currentBlock; 4329 NdefMap->TLVStruct.NdefTLVByte = 4330 (TempLength - PH_FRINFC_MIFARESTD_VAL1); 4331 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4332 TempLength++; 4333 NdefMap->SendRecvBuf[TempLength] = 4334 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 4335 } 4336 break; 4337 4338 case PH_FRINFC_MIFARESTD_VAL15: 4339 default: 4340 if (NdefMap->TLVStruct.prevLenByteValue >= 4341 PH_FRINFC_MIFARESTD_NDEFTLV_L) { 4342 /* In last write ndef length, only T of TLV is updated and 4343 length (L) field of TLV is updated now */ 4344 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_L; 4345 TempLength++; 4346 NdefMap->SendRecvBuf[TempLength] = 4347 (uint8_t)(NdefMap->TLVStruct.prevLenByteValue >> 4348 PH_FRINFC_MIFARESTD_RIGHTSHIFT8); 4349 TempLength++; 4350 NdefMap->SendRecvBuf[TempLength] = 4351 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 4352 } else { 4353 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4354 TempLength++; 4355 NdefMap->TLVStruct.NULLTLVCount = PH_FRINFC_MIFARESTD_VAL2; 4356 NdefMap->TLVStruct.NdefTLVBlock = 4357 NdefMap->StdMifareContainer.currentBlock; 4358 NdefMap->TLVStruct.NdefTLVByte = 4359 (TempLength - PH_FRINFC_MIFARESTD_VAL1); 4360 NdefMap->SendRecvBuf[TempLength] = PH_FRINFC_MIFARESTD_NDEFTLV_T; 4361 TempLength++; 4362 NdefMap->SendRecvBuf[TempLength] = 4363 (uint8_t)NdefMap->TLVStruct.prevLenByteValue; 4364 } 4365 break; 4366 } 4367 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 4368 4369 return; 4370 } 4371 4372 /****************************************************************************** 4373 * Function phFriNfc_MifStd_H_RdTLV 4374 * 4375 * Description This function reads the TLV block. 4376 * 4377 * Returns This function return NFCSTATUS_SUCCESS in case of success 4378 * In case of failure returns other failure value. 4379 * 4380 ******************************************************************************/ 4381 static NFCSTATUS phFriNfc_MifStd_H_RdTLV(phFriNfc_NdefMap_t* NdefMap) { 4382 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4383 4384 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RD_TLV; 4385 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE; 4386 4387 Result = phFriNfc_MifStd_H_Rd16Bytes( 4388 NdefMap, NdefMap->StdMifareContainer.currentBlock); 4389 4390 return Result; 4391 } 4392 4393 /****************************************************************************** 4394 * Function phFriNfc_MifStd_H_ProRdTLV 4395 * 4396 * Description This function processes the read TLV block. 4397 * 4398 * Returns This function return NFCSTATUS_SUCCESS in case of success 4399 * In case of failure returns other failure value. 4400 * 4401 ******************************************************************************/ 4402 static NFCSTATUS phFriNfc_MifStd_H_ProRdTLV(phFriNfc_NdefMap_t* NdefMap) { 4403 NFCSTATUS Result = 4404 PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST); 4405 uint8_t TempLength = PH_FRINFC_MIFARESTD_VAL0, 4406 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG1; 4407 4408 /*TempLength = (uint8_t)(((NdefMap->TLVStruct.NULLTLVCount >= 4409 PH_FRINFC_MIFARESTD_VAL2) && 4410 (NdefMap->TLVStruct.BytesRemainLinTLV > 0xFE))? 4411 ((NdefMap->TLVStruct.NdefTLVByte + 4412 PH_FRINFC_MIFARESTD_VAL2)% 4413 PH_FRINFC_MIFARESTD_VAL16): 4414 ((NdefMap->TLVStruct.NdefTLVByte + 4415 PH_FRINFC_MIFARESTD_VAL4)% 4416 PH_FRINFC_MIFARESTD_VAL16));*/ 4417 4418 TempLength = (uint8_t)( 4419 (NdefMap->TLVStruct.BytesRemainLinTLV <= 0xFE) 4420 ? ((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_MIFARESTD_VAL2) % 4421 PH_FRINFC_MIFARESTD_VAL16) 4422 : ((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_MIFARESTD_VAL4) % 4423 PH_FRINFC_MIFARESTD_VAL16)); 4424 4425 if ((*NdefMap->SendRecvLength == PH_FRINFC_MIFARESTD_BYTES_READ) && 4426 (NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize)) { 4427 if (NdefMap->TLVStruct.BytesRemainLinTLV != 0) { 4428 NDEFFlag = PH_FRINFC_MIFARESTD_FLAG0; 4429 /* To read the remaining length (L) in TLV */ 4430 Result = phFriNfc_MifStd_H_RemainTLV(NdefMap, &NDEFFlag, &TempLength); 4431 } 4432 } 4433 4434 return Result; 4435 } 4436 4437 /****************************************************************************** 4438 * Function phFriNfc_MifStd_H_WrTermTLV 4439 * 4440 * Description This function is used to write the terminator TLV. 4441 * 4442 * Returns This function return NFCSTATUS_SUCCESS in case of success 4443 * In case of failure returns other failure value. 4444 * 4445 ******************************************************************************/ 4446 static NFCSTATUS phFriNfc_MifStd_H_WrTermTLV(phFriNfc_NdefMap_t* NdefMap) { 4447 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4448 uint8_t index = PH_FRINFC_MIFARESTD_VAL0; 4449 4450 /* Change the state to check ndef compliancy */ 4451 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_TERM_TLV; 4452 4453 NdefMap->SendRecvBuf[index] = NdefMap->StdMifareContainer.currentBlock; 4454 index++; 4455 NdefMap->SendRecvBuf[index] = PH_FRINFC_MIFARESTD_TERMTLV_T; 4456 index++; 4457 4458 while (index < PH_FRINFC_MIFARESTD_WR_A_BLK) { 4459 NdefMap->SendRecvBuf[index] = PH_FRINFC_MIFARESTD_NULLTLV_T; 4460 index++; 4461 } 4462 4463 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_MIFARESTD_FLAG0; 4464 4465 Result = phFriNfc_MifStd_H_WrTLV(NdefMap); 4466 4467 return Result; 4468 } 4469 4470 /****************************************************************************** 4471 * Function phFriNfc_MifStd_H_ProWrABlock 4472 * 4473 * Description This function processes the write a block. 4474 * 4475 * Returns This function return NFCSTATUS_SUCCESS in case of success 4476 * In case of failure returns other failure value. 4477 * 4478 ******************************************************************************/ 4479 static NFCSTATUS phFriNfc_MifStd_H_ProWrABlock(phFriNfc_NdefMap_t* NdefMap) { 4480 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4481 4482 NdefMap->StdMifareContainer.WrLength = PH_FRINFC_MIFARESTD_VAL0; 4483 if (NdefMap->ApduBuffIndex < (uint16_t)NdefMap->ApduBufferSize) { 4484 /* Remaining bytes to write < 16 */ 4485 if (NdefMap->StdMifareContainer.RemainingBufFlag == 4486 PH_FRINFC_MIFARESTD_FLAG1) { 4487 /* Write complete, so next byte shall be */ 4488 NdefMap->StdMifareContainer.internalLength = *NdefMap->DataCount; 4489 4490 /* Copy bytes less than 16 to internal buffer 4491 for the next write this can be used */ 4492 memcpy(NdefMap->StdMifareContainer.internalBuf, 4493 NdefMap->StdMifareContainer.Buffer, 4494 NdefMap->StdMifareContainer.internalLength); 4495 4496 /* Increment the Send Buffer index */ 4497 NdefMap->ApduBuffIndex += NdefMap->NumOfBytesWritten; 4498 4499 NdefMap->StdMifareContainer.remainingSize -= NdefMap->NumOfBytesWritten; 4500 4501 NdefMap->StdMifareContainer.RemainingBufFlag = PH_FRINFC_MIFARESTD_VAL0; 4502 /* Check for the End of Card */ 4503 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 4504 (uint8_t)((NdefMap->StdMifareContainer.remainingSize == 4505 PH_FRINFC_MIFARESTD_VAL0) 4506 ? PH_FRINFC_MIFARESTD_FLAG1 4507 : PH_FRINFC_MIFARESTD_FLAG0); 4508 4509 NdefMap->TLVStruct.SetTermTLVFlag = (uint8_t)( 4510 ((NdefMap->StdMifareContainer.remainingSize == 4511 PH_FRINFC_MIFARESTD_VAL0) || 4512 (NdefMap->TLVStruct.SetTermTLVFlag == PH_FRINFC_MIFARESTD_FLAG1)) 4513 ? PH_FRINFC_MIFARESTD_FLAG1 4514 : PH_FRINFC_MIFARESTD_FLAG0); 4515 4516 } /* internal Buffer > Send Buffer */ 4517 else if (NdefMap->StdMifareContainer.internalBufFlag == 4518 PH_FRINFC_MIFARESTD_FLAG1) { 4519 memcpy(NdefMap->StdMifareContainer.internalBuf, 4520 NdefMap->StdMifareContainer.Buffer, *NdefMap->DataCount); 4521 4522 NdefMap->StdMifareContainer.internalLength = *NdefMap->DataCount; 4523 4524 /* Increment the Send Buffer index */ 4525 NdefMap->ApduBuffIndex += NdefMap->NumOfBytesWritten; 4526 4527 NdefMap->StdMifareContainer.remainingSize -= NdefMap->NumOfBytesWritten; 4528 4529 NdefMap->StdMifareContainer.internalBufFlag = PH_FRINFC_MIFARESTD_FLAG0; 4530 /* Check for the End of Card */ 4531 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 4532 (uint8_t)(((NdefMap->StdMifareContainer.remainingSize == 4533 PH_FRINFC_MIFARESTD_VAL0) && 4534 (NdefMap->StdMifareContainer.internalLength == 4535 PH_FRINFC_MIFARESTD_VAL0)) 4536 ? PH_FRINFC_MIFARESTD_FLAG1 4537 : PH_FRINFC_MIFARESTD_FLAG0); 4538 4539 NdefMap->TLVStruct.SetTermTLVFlag = (uint8_t)( 4540 ((NdefMap->StdMifareContainer.remainingSize == 4541 PH_FRINFC_MIFARESTD_VAL0) || 4542 (NdefMap->TLVStruct.SetTermTLVFlag == PH_FRINFC_MIFARESTD_FLAG1)) 4543 ? PH_FRINFC_MIFARESTD_FLAG1 4544 : PH_FRINFC_MIFARESTD_FLAG0); 4545 } else { 4546 NdefMap->StdMifareContainer.internalLength = 0; 4547 /* Increment the Send Buffer index */ 4548 NdefMap->ApduBuffIndex += NdefMap->NumOfBytesWritten; 4549 NdefMap->StdMifareContainer.remainingSize -= NdefMap->NumOfBytesWritten; 4550 4551 /* Check for the End of Card */ 4552 if ((NdefMap->StdMifareContainer.remainingSize == 4553 PH_FRINFC_MIFARESTD_VAL0) || 4554 (NdefMap->ApduBuffIndex == NdefMap->ApduBufferSize)) { 4555 NdefMap->StdMifareContainer.ReadWriteCompleteFlag = 4556 (uint8_t)((NdefMap->StdMifareContainer.remainingSize == 0) 4557 ? PH_FRINFC_MIFARESTD_FLAG1 4558 : PH_FRINFC_MIFARESTD_FLAG0); 4559 4560 if (NdefMap->StdMifareContainer.internalLength == 4561 PH_FRINFC_MIFARESTD_VAL0) { 4562 NdefMap->StdMifareContainer.currentBlock++; 4563 /* Mifare 4k Card, After 128th Block 4564 each sector = 16 blocks in Mifare 4k */ 4565 Result = ((NdefMap->StdMifareContainer.remainingSize == 0) 4566 ? Result 4567 : phFriNfc_MifStd_H_BlkChk(NdefMap)); 4568 NdefMap->StdMifareContainer.NdefBlocks++; 4569 } 4570 NdefMap->TLVStruct.SetTermTLVFlag = (uint8_t)( 4571 ((NdefMap->StdMifareContainer.remainingSize == 4572 PH_FRINFC_MIFARESTD_VAL0) || 4573 (NdefMap->TLVStruct.SetTermTLVFlag == PH_FRINFC_MIFARESTD_FLAG1)) 4574 ? PH_FRINFC_MIFARESTD_FLAG1 4575 : PH_FRINFC_MIFARESTD_FLAG0); 4576 } else { 4577 NdefMap->StdMifareContainer.currentBlock++; 4578 NdefMap->StdMifareContainer.WrLength = 4579 (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); 4580 /* Mifare 4k Card, After 128th Block 4581 each sector = 16 blocks in Mifare 4k */ 4582 Result = phFriNfc_MifStd_H_BlkChk(NdefMap); 4583 if (Result == NFCSTATUS_SUCCESS) { 4584 NdefMap->StdMifareContainer.NdefBlocks++; 4585 Result = ((NdefMap->StdMifareContainer.AuthDone == 4586 PH_FRINFC_MIFARESTD_FLAG1) 4587 ? phFriNfc_MifStd_H_WrABlock(NdefMap) 4588 : phFriNfc_MifStd_H_AuthSector(NdefMap)); 4589 } 4590 } 4591 } 4592 } else { 4593 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST); 4594 } 4595 4596 if ((Result == NFCSTATUS_SUCCESS) && 4597 (NdefMap->TLVStruct.SetTermTLVFlag != PH_FRINFC_MIFARESTD_FLAG1) && 4598 (NdefMap->StdMifareContainer.remainingSize > PH_FRINFC_MIFARESTD_VAL0)) { 4599 Result = phFriNfc_MifStd_H_WrTermTLV(NdefMap); 4600 } else { 4601 if ((Result == NFCSTATUS_SUCCESS) && 4602 (NdefMap->TLVStruct.SetTermTLVFlag == PH_FRINFC_MIFARESTD_FLAG1)) { 4603 /* Write the length to the L field in the TLV */ 4604 NdefMap->StdMifareContainer.TempBlockNo = 4605 NdefMap->StdMifareContainer.currentBlock; 4606 phFriNfc_MifStd_H_SetNdefBlkAuth(NdefMap); 4607 NdefMap->StdMifareContainer.currentBlock = 4608 NdefMap->TLVStruct.NdefTLVBlock; 4609 Result = phFriNfc_MifStd_H_RdtoWrNdefLen(NdefMap); 4610 } 4611 } 4612 4613 return Result; 4614 } 4615 4616 /****************************************************************************** 4617 * Function phFriNfc_MifStd_H_CallDisCon 4618 * 4619 * Description This function trigger disconnect after the authentication 4620 * has failed. 4621 * 4622 * Returns This function return NFCSTATUS_PENDING in case of success 4623 * In case of failure returns other failure value. 4624 * 4625 ******************************************************************************/ 4626 static NFCSTATUS phFriNfc_MifStd_H_CallDisCon(phFriNfc_NdefMap_t* NdefMap) { 4627 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4628 4629 /* Set Ndef State */ 4630 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_DISCONNECT; 4631 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 4632 NdefMap->MapCompletionInfo.Context = NdefMap; 4633 4634 Result = phNxNciExtns_MifareStd_Reconnect(); 4635 4636 return Result; 4637 } 4638 4639 /****************************************************************************** 4640 * Function phFriNfc_MifStd_H_CallConnect 4641 * 4642 * Description This function sets card state to connect after the 4643 * authentication has failed. 4644 * 4645 * Returns NFCSTATUS_SUCCESS 4646 * 4647 ******************************************************************************/ 4648 static NFCSTATUS phFriNfc_MifStd_H_CallConnect(phFriNfc_NdefMap_t* NdefMap) { 4649 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4650 4651 /* Set Ndef State */ 4652 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_CONNECT; 4653 4654 return Result; 4655 } 4656 4657 /****************************************************************************** 4658 * Function phFriNfc_MifStd1k_H_BlkChk 4659 * 4660 * Description This function used to update the current block. 4661 * 4662 * Returns void 4663 * 4664 ******************************************************************************/ 4665 static void phFriNfc_MifStd1k_H_BlkChk(phFriNfc_NdefMap_t* NdefMap, 4666 uint8_t SectorID, uint8_t* callbreak) { 4667 /* every last block of a sector needs to be skipped */ 4668 if (((NdefMap->StdMifareContainer.currentBlock + PH_FRINFC_MIFARESTD_INC_1) % 4669 PH_FRINFC_MIFARESTD_BLK4) == 0) { 4670 NdefMap->StdMifareContainer.currentBlock++; 4671 } else { 4672 if (NdefMap->StdMifareContainer.aid[SectorID] == 4673 PH_FRINFC_MIFARESTD_NDEF_COMP) { 4674 /* Check whether the block is first block of a (next)new sector and 4675 also check if it is first block then internal length is zero 4676 or not. Because once Authentication is done for the sector again 4677 we should not authenticate it again */ 4678 if ((NdefMap->StdMifareContainer.currentBlock == 4679 (SectorID * PH_FRINFC_MIFARESTD_BLK4)) && 4680 (NdefMap->StdMifareContainer.internalLength == 0)) { 4681 NdefMap->StdMifareContainer.AuthDone = 0; 4682 } 4683 *callbreak = 1; 4684 } else { 4685 NdefMap->StdMifareContainer.currentBlock += PH_FRINFC_MIFARESTD_BLK4; 4686 } 4687 } 4688 4689 return; 4690 } 4691 4692 /****************************************************************************** 4693 * Function phFrinfc_MifareClassic_GetContainerSize 4694 * 4695 * Description This function calculate the card size. 4696 * 4697 * Returns This function return NFCSTATUS_SUCCESS in case of success 4698 * In case of failure returns other failure value. 4699 * 4700 ******************************************************************************/ 4701 NFCSTATUS 4702 phFrinfc_MifareClassic_GetContainerSize(const phFriNfc_NdefMap_t* NdefMap, 4703 uint32_t* maxSize, 4704 uint32_t* actualSize) { 4705 NFCSTATUS result = NFCSTATUS_SUCCESS; 4706 uint16_t valid_no_of_bytes = 0; 4707 uint8_t sect_aid_index = 0; 4708 /* Mifare std card */ 4709 4710 /* Max size is the number of NDEF compliant blocks in the card 4711 multiplied by 16 bytes */ 4712 4713 /* Skip all the non ndef sectors */ 4714 while ((sect_aid_index < PH_FRINFC_NDEFMAP_MIFARESTD_TOTALNO_BLK) && 4715 (PH_FRINFC_MIFARESTD_NON_NDEF_COMP == 4716 NdefMap->StdMifareContainer.aid[sect_aid_index])) { 4717 sect_aid_index++; 4718 } 4719 4720 /* Parse only the contiguous NDEF sectors for the max size calculation */ 4721 while ((sect_aid_index < PH_FRINFC_NDEFMAP_MIFARESTD_TOTALNO_BLK) && 4722 (PH_FRINFC_MIFARESTD_NDEF_COMP == 4723 NdefMap->StdMifareContainer.aid[sect_aid_index])) { 4724 if (((PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD == NdefMap->CardType) || 4725 (PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD == NdefMap->CardType)) && 4726 (sect_aid_index >= 32)) { 4727 /* Mifare classic card of 4k size, sector >= 32 has 4728 16 blocks per sector and in that 15 blocks are valid data blocks 4729 16 is the block number in a sector 4730 15 is the number of valid data blocks in a sector 4731 */ 4732 valid_no_of_bytes += (uint16_t)(16 * 15); 4733 } else { 4734 valid_no_of_bytes += (uint16_t)(16 * 3); 4735 } 4736 4737 sect_aid_index++; 4738 if (16 == sect_aid_index) { 4739 /* Because sector index is 16, that is "MAD 2" block 4740 For calculating size MAD block shall be ignored 4741 */ 4742 sect_aid_index++; 4743 } 4744 } 4745 /* The below check is for the 3 byte length format of the NDEF TLV 4746 If the length field > 255, Max size will less by 4 4747 else Max size will less by 2 (Type and Length of the NDEF TLV 4748 has to be skipped to provide the maximum size in the card */ 4749 *maxSize = (valid_no_of_bytes > 0xFF) ? (valid_no_of_bytes - 4) 4750 : (valid_no_of_bytes - 2); 4751 4752 *actualSize = NdefMap->TLVStruct.BytesRemainLinTLV; 4753 4754 return result; 4755 } 4756 4757 /****************************************************************************** 4758 * Function phFriNfc_MifareStdMap_ConvertToReadOnly 4759 * 4760 * Description This function converts the Mifare card to read-only. 4761 * It check preconditions before converting to read only. 4762 * 4763 * Returns This function return NFCSTATUS_PENDING in case of success 4764 * In case of failure returns other failure value. 4765 * 4766 ******************************************************************************/ 4767 NFCSTATUS 4768 phFriNfc_MifareStdMap_ConvertToReadOnly(phFriNfc_NdefMap_t* NdefMap, 4769 const uint8_t* ScrtKeyB) { 4770 NFCSTATUS result = NFCSTATUS_SUCCESS; 4771 uint8_t totalNoSectors = 0, sectorTrailerBlockNo = 0; 4772 4773 if (NdefMap == NULL) { 4774 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 4775 } else if (PH_NDEFMAP_CARD_STATE_INVALID == NdefMap->CardState) { 4776 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_STATE); 4777 } else { 4778 /* card state is PH_NDEFMAP_CARD_STATE_READ_WRITE now */ 4779 /* get AID array and parse */ 4780 if (PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD == NdefMap->CardType) { 4781 totalNoSectors = PH_FRINFC_MIFARESTD1K_TOTAL_SECTOR; 4782 } else if (PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD == NdefMap->CardType) { 4783 totalNoSectors = PH_FRINFC_MIFARESTD2K_TOTAL_SECTOR; 4784 } else if (PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD == NdefMap->CardType) { 4785 totalNoSectors = PH_FRINFC_MIFARESTD4K_TOTAL_SECTOR; 4786 } 4787 4788 /* Store Key B in the context */ 4789 if (ScrtKeyB == NULL) { 4790 memset(NdefMap->StdMifareContainer.UserScrtKeyB, 4791 PH_FRINFC_MIFARESTD_DEFAULT_KEY, PH_FRINFC_MIFARESTD_KEY_LEN); 4792 } else { 4793 memcpy(NdefMap->StdMifareContainer.UserScrtKeyB, ScrtKeyB, 4794 PH_FRINFC_MIFARESTD_KEY_LEN); 4795 } 4796 4797 NdefMap->StdMifareContainer.TotalNoSectors = totalNoSectors; 4798 if (totalNoSectors == 0) { 4799 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 4800 } else { 4801 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_MIFARESTD_FLAG0; 4802 NdefMap->StdMifareContainer.RdBeforeWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 4803 NdefMap->StdMifareContainer.WrNdefFlag = PH_FRINFC_MIFARESTD_FLAG0; 4804 NdefMap->StdMifareContainer.internalLength = PH_FRINFC_MIFARESTD_VAL0; 4805 NdefMap->StdMifareContainer.RdAfterWrFlag = PH_FRINFC_MIFARESTD_FLAG0; 4806 NdefMap->StdMifareContainer.AuthDone = PH_FRINFC_MIFARESTD_FLAG0; 4807 NdefMap->StdMifareContainer.NFCforumSectFlag = PH_FRINFC_MIFARESTD_FLAG0; 4808 NdefMap->StdMifareContainer.WriteAcsBitFlag = PH_FRINFC_MIFARESTD_FLAG0; 4809 4810 /* Sector 0 is MAD sector .Start from Sector 1 */ 4811 for (NdefMap->StdMifareContainer.ReadOnlySectorIndex = 4812 PH_FRINFC_MIFARESTD_FLAG1; 4813 NdefMap->StdMifareContainer.ReadOnlySectorIndex < totalNoSectors; 4814 NdefMap->StdMifareContainer.ReadOnlySectorIndex++) { 4815 /* skip MAD sectors */ 4816 if (PH_FRINFC_MIFARESTD_SECTOR_NO16 == 4817 NdefMap->StdMifareContainer.ReadOnlySectorIndex) { 4818 continue; 4819 } 4820 4821 /* if not NDEF compliant skip */ 4822 if (PH_FRINFC_MIFARESTD_NON_NDEF_COMP == 4823 NdefMap->StdMifareContainer 4824 .aid[NdefMap->StdMifareContainer.ReadOnlySectorIndex]) { 4825 continue; 4826 } 4827 4828 if (PH_FRINFC_MIFARESTD_NDEF_COMP == 4829 NdefMap->StdMifareContainer 4830 .aid[NdefMap->StdMifareContainer.ReadOnlySectorIndex]) { 4831 /*get the sector trailer block number */ 4832 sectorTrailerBlockNo = phFriNfc_MifStd_H_GetSectorTrailerBlkNo( 4833 NdefMap->StdMifareContainer.ReadOnlySectorIndex); 4834 NdefMap->StdMifareContainer.currentBlock = sectorTrailerBlockNo; 4835 NdefMap->StdMifareContainer.SectorTrailerBlockNo = 4836 sectorTrailerBlockNo; 4837 4838 /* Proceed to authenticate the sector with Key B 4839 and modify the sector trailor bits to make it read only*/ 4840 result = phFriNfc_MifStd_H_AuthSector(NdefMap); 4841 4842 if (result == NFCSTATUS_PENDING) { 4843 break; 4844 } 4845 } 4846 } /* end for */ 4847 4848 /* There are no NDEF sectors in this card , return */ 4849 if (NdefMap->StdMifareContainer.ReadOnlySectorIndex == totalNoSectors && 4850 NFCSTATUS_PENDING != result) { 4851 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_NO_NDEF_SUPPORT); 4852 } 4853 } /* end else */ 4854 } 4855 4856 return result; 4857 } 4858 4859 /****************************************************************************** 4860 * Function phFriNfc_MifStd_H_GetSectorTrailerBlkNo 4861 * 4862 * Description This function returns the block number of the sector 4863 * trailor for the given sector trailer Id. 4864 * 4865 * Returns uint8_t sectorTrailerblockNumber : sector trailor 4866 * 4867 ******************************************************************************/ 4868 static uint8_t phFriNfc_MifStd_H_GetSectorTrailerBlkNo(uint8_t SectorID) { 4869 uint8_t sectorTrailerblockNumber = 0; 4870 4871 /* every last block of a sector needs to be skipped */ 4872 if (SectorID < PH_FRINFC_MIFARESTD_SECTOR_NO32) { 4873 sectorTrailerblockNumber = (SectorID * PH_FRINFC_MIFARESTD_BLK4) + 3; 4874 } else { 4875 sectorTrailerblockNumber = 4876 ((PH_FRINFC_MIFARESTD_SECTOR_NO32 * PH_FRINFC_MIFARESTD_BLK4) + 4877 ((SectorID - PH_FRINFC_MIFARESTD_SECTOR_NO32) * 4878 PH_FRINFC_MIFARESTD_SECTOR_BLOCKS)) + 4879 15; 4880 } 4881 4882 return sectorTrailerblockNumber; 4883 } 4884 4885 /****************************************************************************** 4886 * Function phFriNfc_MifStd_H_ProSectorTrailorAcsBits 4887 * 4888 * Description This function is called during ConvertToReadonly process to 4889 * Authenticate NDEF compliant Sector. 4890 * 4891 * Returns This function return NFCSTATUS_SUCCESS in case of success 4892 * In case of failure returns other failure value. 4893 * 4894 ******************************************************************************/ 4895 static NFCSTATUS phFriNfc_MifStd_H_ProSectorTrailorAcsBits( 4896 phFriNfc_NdefMap_t* NdefMap) { 4897 NFCSTATUS Result = NFCSTATUS_SUCCESS; 4898 4899 if (*NdefMap->SendRecvLength == PH_FRINFC_MIFARESTD_BYTES_READ) { 4900 if (NdefMap->StdMifareContainer.ReadAcsBitFlag == 4901 PH_FRINFC_MIFARESTD_FLAG1) { 4902 /* check for the correct access bits */ 4903 Result = phFriNfc_MifStd_H_ChkAcsBit(NdefMap); 4904 if (Result == NFCSTATUS_SUCCESS) { 4905 if (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY) { 4906 /* Go to next sector */ 4907 Result = phFriNfc_MifStd_H_ProWrSectorTrailor(NdefMap); 4908 } else { 4909 /* tranceive to write the data into SendRecvBuff */ 4910 Result = phFriNfc_MifStd_H_WrSectorTrailorBlock(NdefMap); 4911 } 4912 } 4913 } 4914 } else { 4915 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER); 4916 } 4917 4918 return Result; 4919 } 4920 4921 /****************************************************************************** 4922 * Function phFriNfc_MifStd_H_WrSectorTrailorBlock 4923 * 4924 * Description This function makes current NDEF compliant Sector ReadOnly 4925 * modify the sector trailor bits and write it to the card. 4926 * 4927 * Returns This function return NFCSTATUS_PENDING in case of success 4928 * In case of failure returns other failure value. 4929 * 4930 ******************************************************************************/ 4931 static NFCSTATUS phFriNfc_MifStd_H_WrSectorTrailorBlock( 4932 phFriNfc_NdefMap_t* NdefMap) { 4933 NFCSTATUS status = NFCSTATUS_PENDING; 4934 4935 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareStdMap_Process; 4936 NdefMap->MapCompletionInfo.Context = NdefMap; 4937 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE; 4938 4939 /* next state (update sector index) */ 4940 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_WRITE_SEC; 4941 4942 /* Buffer Check */ 4943 if (NdefMap->SendRecvBuf != NULL) { 4944 NdefMap->SendRecvBuf[10] = 0x00; 4945 NdefMap->SendRecvBuf[10] = NdefMap->SendRecvBuf[9] | 4946 PH_FRINFC_MIFARESTD_MASK_GPB_WR; /* WR bits 11*/ 4947 4948 /*The NdefMap->SendRecvBuf already has the sector trailor. 4949 modify the bits to make Read Only */ 4950 NdefMap->SendRecvBuf[1] = 4951 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT1; /* 0xD3 */ 4952 NdefMap->SendRecvBuf[2] = 4953 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT2; /* 0xF7 */ 4954 NdefMap->SendRecvBuf[3] = 4955 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT1; /* 0xD3 */ 4956 NdefMap->SendRecvBuf[4] = 4957 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT2; /* 0xF7 */ 4958 NdefMap->SendRecvBuf[5] = 4959 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT1; /* 0xD3 */ 4960 NdefMap->SendRecvBuf[6] = 4961 PH_FRINFC_NDEFMAP_MIFARESTD_AUTH_NDEFSECT2; /* 0xF7 */ 4962 4963 NdefMap->SendRecvBuf[7] = 4964 PH_FRINFC_MIFARESTD_NFCSECT_RDACS_BYTE6; /* 0x0F */ 4965 NdefMap->SendRecvBuf[8] = 4966 PH_FRINFC_MIFARESTD_NFCSECT_RDACS_BYTE7; /* 0x07 */ 4967 NdefMap->SendRecvBuf[9] = 4968 PH_FRINFC_MIFARESTD_NFCSECT_RDACS_BYTE8; /* 0x8F */ 4969 4970 NdefMap->SendRecvBuf[11] = NdefMap->StdMifareContainer.UserScrtKeyB[0]; 4971 NdefMap->SendRecvBuf[12] = NdefMap->StdMifareContainer.UserScrtKeyB[1]; 4972 NdefMap->SendRecvBuf[13] = NdefMap->StdMifareContainer.UserScrtKeyB[2]; 4973 NdefMap->SendRecvBuf[14] = NdefMap->StdMifareContainer.UserScrtKeyB[3]; 4974 NdefMap->SendRecvBuf[15] = NdefMap->StdMifareContainer.UserScrtKeyB[4]; 4975 NdefMap->SendRecvBuf[16] = NdefMap->StdMifareContainer.UserScrtKeyB[5]; 4976 4977 /* Write to Ndef Sector Block */ 4978 NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL0] = 4979 NdefMap->StdMifareContainer.currentBlock; 4980 4981 /* Copy Ndef Sector Block into buffer */ 4982 memcpy(NdefMap->StdMifareContainer.Buffer, 4983 &(NdefMap->SendRecvBuf[PH_FRINFC_MIFARESTD_VAL1]), 4984 PH_FRINFC_MIFARESTD_BLOCK_BYTES); 4985 4986 /* Write from here */ 4987 NdefMap->SendLength = MIFARE_MAX_SEND_BUF_TO_WRITE; 4988 NdefMap->Cmd.MfCmd = phHal_eMifareWrite16; 4989 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; 4990 4991 /* Call the Overlapped HAL Transceive function */ 4992 status = phFriNfc_ExtnsTransceive(NdefMap->pTransceiveInfo, NdefMap->Cmd, 4993 NdefMap->SendRecvBuf, NdefMap->SendLength, 4994 NdefMap->SendRecvLength); 4995 } else { 4996 /* Error: The control should not ideally come here. 4997 Return Error.*/ 4998 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_FAILED); 4999 } 5000 5001 return status; 5002 } 5003 5004 /****************************************************************************** 5005 * Function phFriNfc_MifStd_H_ProWrSectorTrailor 5006 * 5007 * Description This function makes next NDEF compliant Sector ReadOnly. 5008 * 5009 * Returns This function return NFCSTATUS_SUCCESS in case of success 5010 * In case of failure returns other failure value. 5011 * 5012 ******************************************************************************/ 5013 static NFCSTATUS phFriNfc_MifStd_H_ProWrSectorTrailor( 5014 phFriNfc_NdefMap_t* NdefMap) { 5015 NFCSTATUS status = NFCSTATUS_FAILED; 5016 uint8_t sectorTrailerBlockNo = 0; 5017 5018 /*Increment Sector Index */ 5019 NdefMap->StdMifareContainer.ReadOnlySectorIndex++; 5020 5021 /* skip if MAD2 */ 5022 if (PH_FRINFC_MIFARESTD_SECTOR_NO16 == 5023 NdefMap->StdMifareContainer.ReadOnlySectorIndex) { 5024 NdefMap->StdMifareContainer.ReadOnlySectorIndex++; 5025 } 5026 5027 /* if current sector index exceeds total sector index then 5028 all ndef sectors are made readonly then return success 5029 If a NON def sector is encountered return success*/ 5030 if (NdefMap->StdMifareContainer.ReadOnlySectorIndex >= 5031 NdefMap->StdMifareContainer.TotalNoSectors || 5032 PH_FRINFC_MIFARESTD_NON_NDEF_COMP == 5033 NdefMap->StdMifareContainer 5034 .aid[NdefMap->StdMifareContainer.ReadOnlySectorIndex]) { 5035 status = NFCSTATUS_SUCCESS; 5036 } else if (PH_FRINFC_MIFARESTD_NDEF_COMP == 5037 NdefMap->StdMifareContainer 5038 .aid[NdefMap->StdMifareContainer.ReadOnlySectorIndex]) { 5039 /* Convert next NDEF sector to read only */ 5040 sectorTrailerBlockNo = phFriNfc_MifStd_H_GetSectorTrailerBlkNo( 5041 NdefMap->StdMifareContainer.ReadOnlySectorIndex); 5042 NdefMap->StdMifareContainer.currentBlock = sectorTrailerBlockNo; 5043 NdefMap->StdMifareContainer.SectorTrailerBlockNo = sectorTrailerBlockNo; 5044 5045 status = phFriNfc_MifStd_H_AuthSector(NdefMap); 5046 } 5047 5048 return status; 5049 } 5050 5051 /****************************************************************************** 5052 * Function phFriNfc_MifStd_H_ProWrSectorTrailor 5053 * 5054 * Description This function checks mapping spec version. 5055 * 5056 * Returns This function return NFCSTATUS_SUCCESS in case of success 5057 * In case of failure returns other failure value. 5058 * 5059 ******************************************************************************/ 5060 static NFCSTATUS phFriNfc_MapTool_ChkSpcVer(const phFriNfc_NdefMap_t* NdefMap, 5061 uint8_t VersionIndex) { 5062 NFCSTATUS status = NFCSTATUS_SUCCESS; 5063 5064 uint8_t TagVerNo = NdefMap->SendRecvBuf[VersionIndex]; 5065 5066 if (TagVerNo == 0) { 5067 /* Return Status Error invalid format */ 5068 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_FORMAT); 5069 } else { 5070 switch (NdefMap->CardType) { 5071 case PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD: 5072 case PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD: 5073 case PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD: { 5074 /* calculate the major and minor version number of Mifare std version 5075 * number */ 5076 status = 5077 ((((PH_NFCFRI_MFSTDMAP_NFCDEV_MAJOR_VER_NUM == 5078 PH_NFCFRI_MFSTDMAP_GET_MAJOR_TAG_VERNO(TagVerNo)) && 5079 (PH_NFCFRI_MFSTDMAP_NFCDEV_MINOR_VER_NUM == 5080 PH_NFCFRI_MFSTDMAP_GET_MINOR_TAG_VERNO(TagVerNo))) || 5081 ((PH_NFCFRI_MFSTDMAP_NFCDEV_MAJOR_VER_NUM == 5082 PH_NFCFRI_MFSTDMAP_GET_MAJOR_TAG_VERNO(TagVerNo)) && 5083 (PH_NFCFRI_MFSTDMAP_NFCDEV_MINOR_VER_NUM < 5084 PH_NFCFRI_MFSTDMAP_GET_MINOR_TAG_VERNO(TagVerNo)))) 5085 ? NFCSTATUS_SUCCESS 5086 : PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_FORMAT)); 5087 break; 5088 } 5089 5090 default: { 5091 /* calculate the major and minor version number of T3VerNo */ 5092 if (((PH_NFCFRI_NDEFMAP_NFCDEV_MAJOR_VER_NUM == 5093 PH_NFCFRI_NDEFMAP_GET_MAJOR_TAG_VERNO(TagVerNo)) && 5094 (PH_NFCFRI_NDEFMAP_NFCDEV_MINOR_VER_NUM == 5095 PH_NFCFRI_NDEFMAP_GET_MINOR_TAG_VERNO(TagVerNo))) || 5096 ((PH_NFCFRI_NDEFMAP_NFCDEV_MAJOR_VER_NUM == 5097 PH_NFCFRI_NDEFMAP_GET_MAJOR_TAG_VERNO(TagVerNo)) && 5098 (PH_NFCFRI_NDEFMAP_NFCDEV_MINOR_VER_NUM < 5099 PH_NFCFRI_NDEFMAP_GET_MINOR_TAG_VERNO(TagVerNo)))) { 5100 status = PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_SUCCESS); 5101 } else { 5102 if ((PH_NFCFRI_NDEFMAP_NFCDEV_MAJOR_VER_NUM < 5103 PH_NFCFRI_NDEFMAP_GET_MAJOR_TAG_VERNO(TagVerNo)) || 5104 (PH_NFCFRI_NDEFMAP_NFCDEV_MAJOR_VER_NUM > 5105 PH_NFCFRI_NDEFMAP_GET_MAJOR_TAG_VERNO(TagVerNo))) { 5106 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_FORMAT); 5107 } 5108 } 5109 break; 5110 } 5111 } 5112 } 5113 5114 return (status); 5115 } 5116
