2 * Copyright (C) 2010 NXP Semiconductors
\r
4 * Licensed under the Apache License, Version 2.0 (the "License");
\r
5 * you may not use this file except in compliance with the License.
\r
6 * You may obtain a copy of the License at
\r
8 * http://www.apache.org/licenses/LICENSE-2.0
\r
10 * Unless required by applicable law or agreed to in writing, software
\r
11 * distributed under the License is distributed on an "AS IS" BASIS,
\r
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
13 * See the License for the specific language governing permissions and
\r
14 * limitations under the License.
\r
18 * \file phFriNfc_TopazMap.c
\r
19 * \brief NFC Ndef Mapping For Remote Devices.
\r
23 * $Date: Mon Dec 13 14:14:14 2010 $
\r
24 * $Author: ing02260 $
\r
32 #include <phFriNfc_NdefMap.h>
\r
33 #include <phFriNfc_TopazMap.h>
\r
34 #include <phFriNfc_MapTools.h>
\r
35 #include <phFriNfc_OvrHal.h>
\r
37 #ifndef PH_FRINFC_MAP_TOPAZ_DISABLED
\r
38 /*! \ingroup grp_file_attributes
\r
39 * \name NDEF Mapping
\r
41 * File: \ref phFriNfcNdefMap.c
\r
45 #define PHFRINFCTOPAZMAP_FILEREVISION "$Revision: 1.23 $"
\r
46 #define PHFRINFCTOPAZMAP_FILEALIASES "$Aliases: $"
\r
48 /****************** Start of macros ********************/
\r
49 /* Below MACRO is used for the WRITE error scenario,
\r
50 in case PN544 returns error for any WRITE, then
\r
51 read the written block and byte number, to check the data
\r
52 written to the card is correct or not
\r
54 /* #define TOPAZ_RF_ERROR_WORKAROUND */
\r
56 #ifdef FRINFC_READONLY_NDEF
\r
58 #define CC_BLOCK_NUMBER (0x01U)
\r
59 #define LOCK_BLOCK_NUMBER (0x0EU)
\r
61 #define LOCK0_BYTE_NUMBER (0x00U)
\r
62 #define LOCK0_BYTE_VALUE (0xFFU)
\r
64 #define LOCK1_BYTE_NUMBER (0x01U)
\r
65 #define LOCK1_BYTE_VALUE (0x7FU)
\r
67 #define CC_RWA_BYTE_NUMBER (0x03U)
\r
68 #define CC_READ_ONLY_VALUE (0x0FU)
\r
70 #endif /* #ifdef FRINFC_READONLY_NDEF */
\r
72 #ifdef TOPAZ_RF_ERROR_WORKAROUND
\r
74 /* Below MACROs are added for the error returned from HAL, if the
\r
75 below error has occured during the WRITE, then read the error
\r
76 returned blocks to confirm */
\r
77 #define FRINFC_RF_TIMEOUT_89 (0x89U)
\r
78 #define FRINFC_RF_TIMEOUT_90 (0x90U)
\r
80 /* State specific to read after the RF ERROR for the WRITE */
\r
81 #define PH_FRINFC_TOPAZ_STATE_RF_ERROR_READ (0x0FU)
\r
83 #endif /* #ifdef TOPAZ_RF_ERROR_WORKAROUND */
\r
85 /****************** End of macros ********************/
\r
88 * \name Topaz Mapping - Helper Functions
\r
94 * \brief \copydoc page_ovr Helper function for Topaz. This function shall read 8 bytes
\r
97 static NFCSTATUS phFriNfc_Tpz_H_RdBytes(phFriNfc_NdefMap_t *NdefMap,
\r
102 * \brief \copydoc page_ovr Helper function for Topaz. This function shall process
\r
105 static NFCSTATUS phFriNfc_Tpz_H_ProReadID(phFriNfc_NdefMap_t *NdefMap);
\r
108 * \brief \copydoc page_ovr Helper function for Topaz. This function shall process
\r
111 static NFCSTATUS phFriNfc_Tpz_H_ProReadAll(phFriNfc_NdefMap_t *NdefMap);
\r
114 * \brief \copydoc page_ovr Helper function for Topaz. This function depends on
\r
115 * function called by the user
\r
117 static NFCSTATUS phFriNfc_Tpz_H_CallNxtOp(phFriNfc_NdefMap_t *NdefMap);
\r
120 * \brief \copydoc page_ovr Helper function for Topaz. This function checks the CC
\r
123 static NFCSTATUS phFriNfc_Tpz_H_ChkCCBytes(phFriNfc_NdefMap_t *NdefMap);
\r
126 * \brief \copydoc page_ovr Helper function for Topaz. This function finds
\r
129 static NFCSTATUS phFriNfc_Tpz_H_findNDEFTLV(phFriNfc_NdefMap_t *NdefMap);
\r
132 * \brief \copydoc page_ovr Helper function for Topaz. This function writes a
\r
133 * byte into the card
\r
135 static NFCSTATUS phFriNfc_Tpz_H_WrAByte(phFriNfc_NdefMap_t *NdefMap,
\r
142 * \brief \copydoc page_ovr Helper function for Topaz. This function shall process the
\r
145 static NFCSTATUS phFriNfc_Tpz_H_ProWrNMN(phFriNfc_NdefMap_t *NdefMap);
\r
148 * \brief \copydoc page_ovr Helper function for Topaz. This function writes the length field of
\r
151 static NFCSTATUS phFriNfc_Tpz_H_ProWrTLV(phFriNfc_NdefMap_t *NdefMap);
\r
154 * \brief \copydoc page_ovr Helper function for Topaz. This function updates length field
\r
155 * of the NDEF TLV after complete write.
\r
157 static NFCSTATUS phFriNfc_Tpz_H_WrLByte(phFriNfc_NdefMap_t *NdefMap);
\r
160 * \brief \copydoc page_ovr Helper function for Topaz. This function copies the card data
\r
161 * to the user buffer
\r
163 static NFCSTATUS phFriNfc_Tpz_H_CpDataToUsrBuf( phFriNfc_NdefMap_t *NdefMap);
\r
166 * \brief \copydoc page_ovr Helper function for Topaz. This function shall process the
\r
169 static NFCSTATUS phFriNfc_Tpz_H_ProWrUsrData( phFriNfc_NdefMap_t *NdefMap);
\r
172 * \brief \copydoc page_ovr Helper function for Topaz. This function checks the block
\r
173 * number is correct or not
\r
175 static void phFriNfc_Tpz_H_BlkChk(phFriNfc_NdefMap_t *NdefMap);
\r
178 * \brief \copydoc page_ovr Helper function for Topaz. This function writes the 0th
\r
179 * byte of block 1 has Zero
\r
181 static NFCSTATUS phFriNfc_Tpz_H_WrByte0ValE1(phFriNfc_NdefMap_t *NdefMap);
\r
184 * \brief \copydoc page_ovr Helper function for Topaz. This function calls the
\r
185 * completion routine
\r
187 static void phFriNfc_Tpz_H_Complete(phFriNfc_NdefMap_t *NdefMap,
\r
191 * \brief \copydoc page_ovr Helper function for Topaz check ndef. This function checks
\r
192 * the CC byte in check ndef function
\r
194 static NFCSTATUS phFriNfc_Tpz_H_ChkCCinChkNdef(phFriNfc_NdefMap_t *NdefMap);
\r
197 * \brief \copydoc page_ovr Helper function for Topaz check ndef. This function checks
\r
198 * the lock bits and set a card state
\r
200 static void phFriNfc_Tpz_H_ChkLockBits(phFriNfc_NdefMap_t *NdefMap);
\r
203 * \brief \copydoc page_ovr Helper function for Topaz. This function writes CC bytes or
\r
206 static NFCSTATUS phFriNfc_Tpz_H_WrCCorTLV(phFriNfc_NdefMap_t *NdefMap);
\r
208 #ifdef TOPAZ_RF_ERROR_WORKAROUND
\r
211 * \brief \copydoc page_ovr Helper function for Topaz. This function checks the written
\r
216 phFriNfc_Tpz_H_CheckWrittenData (
\r
217 phFriNfc_NdefMap_t *psNdefMap,
\r
218 uint8_t state_rf_error);
\r
220 #endif /* #ifdef TOPAZ_RF_ERROR_WORKAROUND */
\r
223 * \brief \copydoc page_ovr Helper function for Topaz. This function checks the written
\r
224 * CC bytes are correct
\r
226 static NFCSTATUS phFriNfc_Tpz_H_ProCCTLV(phFriNfc_NdefMap_t *NdefMap);
\r
228 void phFriNfc_TopazMap_H_Reset(phFriNfc_NdefMap_t *NdefMap)
\r
230 /* Initialising the Topaz structure variable */
\r
231 NdefMap->TopazContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_INVALID_OPE;
\r
232 NdefMap->TopazContainer.CurrentBlock = PH_FRINFC_TOPAZ_VAL1;
\r
233 NdefMap->TopazContainer.ByteNumber = PH_FRINFC_TOPAZ_VAL0;
\r
234 NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_VAL0;
\r
235 (void)memset(NdefMap->TopazContainer.ReadBuffer, PH_FRINFC_TOPAZ_VAL0,
\r
236 sizeof(NdefMap->TopazContainer.ReadBuffer));
\r
237 NdefMap->TopazContainer.ReadWriteCompleteFlag = PH_FRINFC_TOPAZ_FLAG0;
\r
238 NdefMap->TopazContainer.RemainingSize = PH_FRINFC_TOPAZ_VAL0;
\r
239 (void)memset(NdefMap->TopazContainer.UID, PH_FRINFC_TOPAZ_VAL0,
\r
240 sizeof(NdefMap->TopazContainer.UID));
\r
241 NdefMap->TopazContainer.Cur_RW_Index=0;
\r
242 NdefMap->TopazContainer.ByteRWFrmCard =0;
\r
246 * \brief Check whether a particular Remote Device is NDEF compliant.
\r
248 * The function checks whether the peer device is NDEF compliant.
\r
250 * \param[in] NdefMap Pointer to a valid instance of the \ref phFriNfc_NdefMap_t
\r
251 * structure describing the component context.
\r
253 * \retval NFCSTATUS_PENDING The action has been successfully triggered.
\r
254 * \retval Others An error has occurred.
\r
258 NFCSTATUS phFriNfc_TopazMap_ChkNdef( phFriNfc_NdefMap_t *NdefMap)
\r
260 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
261 NFCSTATUS_INVALID_PARAMETER);
\r
262 if ( NdefMap != NULL)
\r
264 /* Update the previous operation */
\r
265 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE;
\r
266 /* Update the CR index to know from which operation completion
\r
267 routine has to be called */
\r
268 NdefMap->TopazContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_CHK_NDEF;
\r
269 NdefMap->TopazContainer.CurrentBlock = PH_FRINFC_TOPAZ_VAL1;
\r
270 NdefMap->TopazContainer.ByteNumber = PH_FRINFC_TOPAZ_VAL0;
\r
272 /* Set card state */
\r
273 NdefMap->CardType = PH_FRINFC_NDEFMAP_TOPAZ_CARD;
\r
275 /* Change the state to Check Ndef Compliant */
\r
276 NdefMap->State = PH_FRINFC_TOPAZ_STATE_READID;
\r
277 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE;
\r
279 #ifdef TOPAZ_RAW_SUPPORT
\r
280 NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
\r
281 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = PH_FRINFC_TOPAZ_CMD_READID;
\r
283 #ifdef PH_HAL4_ENABLE
\r
284 NdefMap->Cmd.JewelCmd = phHal_eJewel_RID;
\r
286 NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRid;
\r
288 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
290 Result = phFriNfc_Tpz_H_RdBytes(NdefMap, NdefMap->TopazContainer.CurrentBlock,
\r
291 NdefMap->TopazContainer.ByteNumber);
\r
296 #ifdef FRINFC_READONLY_NDEF
\r
299 phFriNfc_TopazMap_ConvertToReadOnly (
\r
300 phFriNfc_NdefMap_t *NdefMap)
\r
302 NFCSTATUS result = NFCSTATUS_SUCCESS;
\r
304 result = phFriNfc_Tpz_H_WrAByte (NdefMap, CC_BLOCK_NUMBER,
\r
305 CC_RWA_BYTE_NUMBER, CC_READ_ONLY_VALUE);
\r
307 if (NFCSTATUS_PENDING == PHNFCSTATUS(result))
\r
309 NdefMap->State = PH_FRINFC_TOPAZ_STATE_WR_CC_BYTE;
\r
314 #endif /* #ifdef FRINFC_READONLY_NDEF */
\r
317 * \brief Initiates Reading of NDEF information from the Remote Device.
\r
319 * The function initiates the reading of NDEF information from a Remote Device.
\r
320 * It performs a reset of the state and starts the action (state machine).
\r
321 * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action
\r
322 * has been triggered.
\r
324 NFCSTATUS phFriNfc_TopazMap_RdNdef( phFriNfc_NdefMap_t *NdefMap,
\r
325 uint8_t *PacketData,
\r
326 uint32_t *PacketDataLength,
\r
329 NFCSTATUS Result = NFCSTATUS_SUCCESS;
\r
331 /* Copy user buffer to the context */
\r
332 NdefMap->ApduBuffer = PacketData;
\r
333 /* Copy user length to the context */
\r
334 NdefMap->ApduBufferSize = *PacketDataLength;
\r
335 /* Update the user memory size to a context variable */
\r
336 NdefMap->NumOfBytesRead = PacketDataLength;
\r
337 /* Number of bytes read from the card is zero.
\r
338 This variable returns the number of bytes read
\r
340 *NdefMap->NumOfBytesRead = PH_FRINFC_TOPAZ_VAL0;
\r
341 /* Index to know the length read */
\r
342 NdefMap->ApduBuffIndex = PH_FRINFC_TOPAZ_VAL0;
\r
343 /* Store the offset in the context */
\r
344 NdefMap->Offset = Offset;
\r
345 /* Update the CR index to know from which operation completion
\r
346 routine has to be called */
\r
347 NdefMap->TopazContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_RD_NDEF;
\r
349 if( (Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || ( NdefMap->PrevOperation ==
\r
350 PH_FRINFC_NDEFMAP_WRITE_OPE))
\r
352 /* If previous operation is not read then the read shall
\r
353 start from BEGIN */
\r
354 NdefMap->Offset = PH_FRINFC_NDEFMAP_SEEK_BEGIN;
\r
355 /* Initialise current block and byte number */
\r
356 NdefMap->TopazContainer.CurrentBlock = PH_FRINFC_TOPAZ_VAL1;
\r
357 NdefMap->TopazContainer.ByteNumber = PH_FRINFC_TOPAZ_VAL0;
\r
358 /* State has to be changed */
\r
359 NdefMap->State = PH_FRINFC_TOPAZ_STATE_READALL;
\r
360 NdefMap->TopazContainer.ReadWriteCompleteFlag =
\r
361 PH_FRINFC_TOPAZ_FLAG0;
\r
362 /* Topaz command = READALL */
\r
363 #ifdef TOPAZ_RAW_SUPPORT
\r
364 NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
\r
365 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = PH_FRINFC_TOPAZ_CMD_READALL;
\r
368 #ifdef PH_HAL4_ENABLE
\r
369 NdefMap->Cmd.JewelCmd = phHal_eJewel_ReadAll;
\r
371 NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelReadAll;
\r
374 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
377 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;
\r
378 /* Offset = Current, but the read has reached the End of Card */
\r
379 if( (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&
\r
380 (NdefMap->TopazContainer.ReadWriteCompleteFlag ==
\r
381 PH_FRINFC_TOPAZ_FLAG1))
\r
383 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
384 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
\r
388 /* if the offset is begin then call READALL else copy the data
\r
389 from the user buffer */
\r
390 Result = ((Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
\r
391 phFriNfc_Tpz_H_RdBytes(NdefMap,
\r
392 NdefMap->TopazContainer.CurrentBlock,
\r
393 NdefMap->TopazContainer.ByteNumber):
\r
394 phFriNfc_Tpz_H_CpDataToUsrBuf(NdefMap));
\r
401 * \brief Initiates Writing of NDEF information to the Remote Device.
\r
403 * The function initiates the writing of NDEF information to a Remote Device.
\r
404 * It performs a reset of the state and starts the action (state machine).
\r
405 * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action
\r
406 * has been triggered.
\r
408 NFCSTATUS phFriNfc_TopazMap_WrNdef( phFriNfc_NdefMap_t *NdefMap,
\r
409 uint8_t *PacketData,
\r
410 uint32_t *PacketDataLength,
\r
413 NFCSTATUS Result = NFCSTATUS_SUCCESS;
\r
414 uint8_t TempByteVal = 0;
\r
415 /* Copy user buffer to the context */
\r
416 NdefMap->ApduBuffer = PacketData;
\r
417 /* Copy user length to the context */
\r
418 NdefMap->ApduBufferSize = *PacketDataLength;
\r
419 /* Index to know the length written */
\r
420 NdefMap->ApduBuffIndex = PH_FRINFC_TOPAZ_VAL0;
\r
421 /* Update the user memory size to a context variable */
\r
422 NdefMap->WrNdefPacketLength = PacketDataLength;
\r
423 /* Number of bytes written to the card is zero.
\r
424 This variable returns the number of bytes written
\r
426 *NdefMap->WrNdefPacketLength = PH_FRINFC_TOPAZ_VAL0;
\r
427 /* Update the CR index to know from which operation completion
\r
428 routine has to be called */
\r
429 NdefMap->TopazContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_WR_NDEF;
\r
430 /* Store the offset in the context */
\r
431 NdefMap->Offset = Offset;
\r
434 if( (Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) ||
\r
435 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE))
\r
437 NdefMap->Offset = PH_FRINFC_NDEFMAP_SEEK_BEGIN;
\r
438 /* Initialise current block and byte number */
\r
439 NdefMap->TopazContainer.CurrentBlock = PH_FRINFC_TOPAZ_VAL1;
\r
440 NdefMap->TopazContainer.ByteNumber = PH_FRINFC_TOPAZ_VAL0;
\r
441 /* State has to be changed */
\r
442 NdefMap->State = PH_FRINFC_TOPAZ_STATE_READALL;
\r
443 /* Topaz command = READALL */
\r
445 #ifdef TOPAZ_RAW_SUPPORT
\r
446 NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
\r
447 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = PH_FRINFC_TOPAZ_CMD_READALL;
\r
449 #ifdef PH_HAL4_ENABLE
\r
450 NdefMap->Cmd.JewelCmd = phHal_eJewel_ReadAll;
\r
452 NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelReadAll;
\r
454 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
455 NdefMap->TopazContainer.ReadWriteCompleteFlag =
\r
456 PH_FRINFC_TOPAZ_FLAG0;
\r
457 NdefMap->TopazContainer.RemainingSize = NdefMap->CardMemSize;
\r
458 TempByteVal = NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL1];
\r
462 /* State has to be changed */
\r
463 NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE;
\r
464 /* copy the user data to write into the card */
\r
465 TempByteVal = NdefMap->ApduBuffer[NdefMap->ApduBuffIndex];
\r
468 /* Update the previous operation to write operation */
\r
469 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;
\r
470 if((Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&
\r
471 (NdefMap->TopazContainer.ReadWriteCompleteFlag ==
\r
472 PH_FRINFC_TOPAZ_FLAG1))
\r
474 /* Offset = Current, but the read has reached the End of Card */
\r
475 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
476 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
\r
480 /* Check the block */
\r
481 phFriNfc_Tpz_H_BlkChk(NdefMap);
\r
482 /* if offset is begin then call READALL else start writing */
\r
483 Result = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
\r
484 phFriNfc_Tpz_H_RdBytes(NdefMap, NdefMap->TopazContainer.CurrentBlock,
\r
485 NdefMap->TopazContainer.ByteNumber):
\r
486 phFriNfc_Tpz_H_WrAByte(NdefMap, NdefMap->TopazContainer.CurrentBlock,
\r
487 NdefMap->TopazContainer.ByteNumber,TempByteVal));
\r
495 * \brief Completion Routine, Processing function, needed to avoid long blocking.
\r
496 * \note The lower (Overlapped HAL) layer must register a pointer to this function as a Completion
\r
497 * Routine in order to be able to notify the component that an I/O has finished and data are
\r
498 * ready to be processed.
\r
502 void phFriNfc_TopazMap_Process( void *Context,
\r
506 phFriNfc_NdefMap_t *psNdefMap = NULL;
\r
508 #ifdef TOPAZ_RF_ERROR_WORKAROUND
\r
510 static uint8_t rf_error_state = 0;
\r
512 #endif /* #ifdef TOPAZ_RF_ERROR_WORKAROUND */
\r
513 #ifdef FRINFC_READONLY_NDEF
\r
514 static uint8_t written_lock_byte = 0;
\r
515 #endif /* #ifdef FRINFC_READONLY_NDEF */
\r
517 psNdefMap = (phFriNfc_NdefMap_t *)Context;
\r
519 if ((Status & PHNFCSTBLOWER) == (NFCSTATUS_SUCCESS & PHNFCSTBLOWER))
\r
521 switch (psNdefMap->State)
\r
523 #ifdef FRINFC_READONLY_NDEF
\r
524 case PH_FRINFC_TOPAZ_STATE_WR_CC_BYTE:
\r
526 if((CC_READ_ONLY_VALUE == *psNdefMap->SendRecvBuf)
\r
527 && (PH_FRINFC_TOPAZ_VAL1 == *psNdefMap->SendRecvLength))
\r
529 written_lock_byte = 0;
\r
530 #ifdef TOPAZ_RAW_SUPPORT
\r
531 *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ;
\r
533 #ifdef PH_HAL4_ENABLE
\r
534 psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read1;
\r
536 psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead1;
\r
537 #endif /* #ifdef PH_HAL4_ENABLE */
\r
538 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
539 Status = phFriNfc_Tpz_H_RdBytes (psNdefMap, LOCK_BLOCK_NUMBER,
\r
540 LOCK0_BYTE_NUMBER);
\r
542 if (NFCSTATUS_PENDING == PHNFCSTATUS(Status))
\r
544 psNdefMap->State = PH_FRINFC_TOPAZ_STATE_RD_LOCK0_BYTE;
\r
549 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
550 NFCSTATUS_INVALID_RECEIVE_LENGTH);
\r
555 case PH_FRINFC_TOPAZ_STATE_RD_LOCK0_BYTE:
\r
557 if (PH_FRINFC_TOPAZ_VAL1 == *psNdefMap->SendRecvLength)
\r
559 Status = phFriNfc_Tpz_H_WrAByte (psNdefMap, LOCK_BLOCK_NUMBER,
\r
560 LOCK0_BYTE_NUMBER,
\r
563 if (NFCSTATUS_PENDING == PHNFCSTATUS(Status))
\r
565 psNdefMap->State = PH_FRINFC_TOPAZ_STATE_WR_LOCK0_BYTE;
\r
571 case PH_FRINFC_TOPAZ_STATE_WR_LOCK0_BYTE:
\r
573 if((LOCK0_BYTE_VALUE == *psNdefMap->SendRecvBuf)
\r
574 && (PH_FRINFC_TOPAZ_VAL1 == *psNdefMap->SendRecvLength))
\r
576 #ifdef TOPAZ_RAW_SUPPORT
\r
577 *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ;
\r
579 #ifdef PH_HAL4_ENABLE
\r
580 psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read1;
\r
582 psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead1;
\r
583 #endif /* #ifdef PH_HAL4_ENABLE */
\r
584 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
585 Status = phFriNfc_Tpz_H_RdBytes (psNdefMap, LOCK_BLOCK_NUMBER,
\r
586 LOCK1_BYTE_NUMBER);
\r
588 if (NFCSTATUS_PENDING == PHNFCSTATUS(Status))
\r
590 psNdefMap->State = PH_FRINFC_TOPAZ_STATE_RD_LOCK1_BYTE;
\r
595 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
596 NFCSTATUS_INVALID_RECEIVE_LENGTH);
\r
600 case PH_FRINFC_TOPAZ_STATE_RD_LOCK1_BYTE:
\r
602 if (PH_FRINFC_TOPAZ_VAL1 == *psNdefMap->SendRecvLength)
\r
604 written_lock_byte = (uint8_t)(*psNdefMap->SendRecvBuf | LOCK1_BYTE_VALUE);
\r
605 Status = phFriNfc_Tpz_H_WrAByte (psNdefMap, LOCK_BLOCK_NUMBER,
\r
606 LOCK1_BYTE_NUMBER,
\r
607 written_lock_byte);
\r
609 if (NFCSTATUS_PENDING == PHNFCSTATUS(Status))
\r
611 psNdefMap->State = PH_FRINFC_TOPAZ_STATE_WR_LOCK1_BYTE;
\r
617 case PH_FRINFC_TOPAZ_STATE_WR_LOCK1_BYTE:
\r
619 if((written_lock_byte == *psNdefMap->SendRecvBuf)
\r
620 && (PH_FRINFC_TOPAZ_VAL1 == *psNdefMap->SendRecvLength))
\r
622 written_lock_byte = 0;
\r
627 written_lock_byte = 0;
\r
628 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
629 NFCSTATUS_INVALID_RECEIVE_LENGTH);
\r
632 #endif /* #ifdef FRINFC_READONLY_NDEF */
\r
633 case PH_FRINFC_TOPAZ_STATE_WRITE:
\r
635 Status = phFriNfc_Tpz_H_ProWrUsrData (psNdefMap);
\r
639 case PH_FRINFC_TOPAZ_STATE_READID:
\r
641 Status = phFriNfc_Tpz_H_ProReadID (psNdefMap);
\r
645 case PH_FRINFC_TOPAZ_STATE_READALL:
\r
647 Status = phFriNfc_Tpz_H_ProReadAll (psNdefMap);
\r
651 case PH_FRINFC_TOPAZ_STATE_WRITE_NMN:
\r
653 Status = phFriNfc_Tpz_H_ProWrNMN (psNdefMap);
\r
657 case PH_FRINFC_TOPAZ_STATE_WRITE_L_TLV:
\r
659 Status = phFriNfc_Tpz_H_ProWrTLV (psNdefMap);
\r
663 case PH_FRINFC_TOPAZ_STATE_WR_CC_OR_TLV:
\r
665 Status = phFriNfc_Tpz_H_ProCCTLV (psNdefMap);
\r
669 #ifdef TOPAZ_RF_ERROR_WORKAROUND
\r
671 case PH_FRINFC_TOPAZ_STATE_RF_ERROR_READ:
\r
673 Status = phFriNfc_Tpz_H_CheckWrittenData (psNdefMap,
\r
678 #endif /* #ifdef TOPAZ_RF_ERROR_WORKAROUND */
\r
682 Status = PHNFCSTVAL (CID_FRI_NFC_NDEF_MAP,
\r
683 NFCSTATUS_INVALID_DEVICE_REQUEST);
\r
690 #ifdef TOPAZ_RF_ERROR_WORKAROUND
\r
692 if ((FRINFC_RF_TIMEOUT_89 == PHNFCSTATUS (Status)) ||
\r
693 (FRINFC_RF_TIMEOUT_90 == PHNFCSTATUS (Status)) ||
\r
694 (NFCSTATUS_RF_TIMEOUT == PHNFCSTATUS (Status)))
\r
696 uint8_t byte_number = 0;
\r
697 uint8_t block_number = 0;
\r
699 rf_error_state = psNdefMap->State;
\r
701 #ifdef TOPAZ_RAW_SUPPORT
\r
703 *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ;
\r
707 #ifdef PH_HAL4_ENABLE
\r
709 psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read1;
\r
713 psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead1;
\r
715 #endif /* #ifdef PH_HAL4_ENABLE */
\r
717 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
719 /* Update the state variable to the new work around state*/
\r
720 psNdefMap->State = PH_FRINFC_TOPAZ_STATE_RF_ERROR_READ;
\r
722 /* Switch is used to know, if the error occured during WRITE or READ */
\r
723 switch (rf_error_state)
\r
725 case PH_FRINFC_TOPAZ_STATE_WRITE_NMN:
\r
727 /* Block and byte number is updated for NMN */
\r
728 byte_number = PH_FRINFC_TOPAZ_VAL0;
\r
729 block_number = PH_FRINFC_TOPAZ_VAL1;
\r
733 case PH_FRINFC_TOPAZ_STATE_WRITE_L_TLV:
\r
735 /* Get the L field of the TLV block */
\r
736 block_number = (uint8_t)(((psNdefMap->TLVStruct.NdefTLVByte +
\r
737 PH_FRINFC_TOPAZ_VAL1) >
\r
738 PH_FRINFC_TOPAZ_VAL7)?
\r
739 (psNdefMap->TLVStruct.NdefTLVBlock +
\r
740 PH_FRINFC_TOPAZ_VAL1):
\r
741 psNdefMap->TLVStruct.NdefTLVBlock);
\r
742 /* Get the L byte */
\r
743 byte_number = (uint8_t)((psNdefMap->TLVStruct.NdefTLVByte +
\r
744 PH_FRINFC_TOPAZ_VAL1) %
\r
745 PH_FRINFC_TOPAZ_VAL8);
\r
749 case PH_FRINFC_TOPAZ_STATE_WR_CC_OR_TLV:
\r
751 switch (psNdefMap->TopazContainer.InternalState)
\r
753 case PH_FRINFC_TOPAZ_WR_CC_BYTE0:
\r
755 /* Block and byte number is updated for the CC byte 0 */
\r
756 block_number = (uint8_t)PH_FRINFC_TOPAZ_VAL1;
\r
757 byte_number = (uint8_t)PH_FRINFC_TOPAZ_VAL0;
\r
761 case PH_FRINFC_TOPAZ_WR_CC_BYTE1:
\r
763 /* Block and byte number is updated for the CC byte 1 */
\r
764 block_number = (uint8_t)PH_FRINFC_TOPAZ_VAL1;
\r
765 byte_number = (uint8_t)PH_FRINFC_TOPAZ_VAL1;
\r
769 case PH_FRINFC_TOPAZ_WR_CC_BYTE2:
\r
771 /* Block and byte number is updated for the CC byte 2 */
\r
772 block_number = (uint8_t)PH_FRINFC_TOPAZ_VAL1;
\r
773 byte_number = (uint8_t)PH_FRINFC_TOPAZ_VAL2;
\r
777 case PH_FRINFC_TOPAZ_WR_CC_BYTE3:
\r
779 /* Block and byte number is updated for the CC byte 3 */
\r
780 block_number = (uint8_t)PH_FRINFC_TOPAZ_VAL1;
\r
781 byte_number = (uint8_t)PH_FRINFC_TOPAZ_VAL3;
\r
785 case PH_FRINFC_TOPAZ_WR_T_OF_TLV:
\r
787 /* Block and byte number is updated for the Type field of the TLV */
\r
788 block_number = psNdefMap->TLVStruct.NdefTLVBlock;
\r
789 byte_number = (uint8_t)psNdefMap->TLVStruct.NdefTLVByte;
\r
798 } /* switch (psNdefMap->TopazContainer.InternalState) */
\r
802 case PH_FRINFC_TOPAZ_STATE_WRITE:
\r
804 /* Block and byte number is updated for the written error data */
\r
805 block_number = psNdefMap->TopazContainer.CurrentBlock;
\r
806 byte_number = psNdefMap->TopazContainer.ByteNumber;
\r
812 /* Error occured is not during WRITE, so update
\r
813 state variable to the previous state */
\r
814 psNdefMap->State = rf_error_state;
\r
817 } /* switch (rf_error_state) */
\r
819 /* The below check is added, to know if the error is for
\r
820 the WRITE or READ scenario,
\r
821 If the error is for READ, then state variable is not updated
\r
822 If the error is for WRITE, then state variable is updated with
\r
823 PH_FRINFC_TOPAZ_STATE_RF_ERROR_READ value */
\r
824 if (PH_FRINFC_TOPAZ_STATE_RF_ERROR_READ == psNdefMap->State)
\r
826 /* Read the data with the updated block and byte number */
\r
827 Status = phFriNfc_Tpz_H_RdBytes (psNdefMap, block_number,
\r
832 #endif /* #ifdef TOPAZ_RF_ERROR_WORKAROUND */
\r
835 /* Call Completion Routine, if Status != PENDING */
\r
836 if (NFCSTATUS_PENDING != Status)
\r
838 phFriNfc_Tpz_H_Complete(psNdefMap, Status);
\r
843 #ifdef TOPAZ_RF_ERROR_WORKAROUND
\r
847 phFriNfc_Tpz_H_CheckWrittenData (
\r
848 phFriNfc_NdefMap_t *psNdefMap,
\r
849 uint8_t state_rf_error)
\r
851 NFCSTATUS result = NFCSTATUS_SUCCESS;
\r
853 switch (state_rf_error)
\r
855 case PH_FRINFC_TOPAZ_STATE_WRITE:
\r
857 result = phFriNfc_Tpz_H_ProWrUsrData (psNdefMap);
\r
861 case PH_FRINFC_TOPAZ_STATE_WRITE_NMN:
\r
863 result = phFriNfc_Tpz_H_ProWrNMN (psNdefMap);
\r
867 case PH_FRINFC_TOPAZ_STATE_WRITE_L_TLV:
\r
869 result = phFriNfc_Tpz_H_ProWrTLV (psNdefMap);
\r
873 case PH_FRINFC_TOPAZ_STATE_WR_CC_OR_TLV:
\r
875 result = phFriNfc_Tpz_H_ProCCTLV (psNdefMap);
\r
889 #endif /* #ifdef TOPAZ_RF_ERROR_WORKAROUND */
\r
891 static NFCSTATUS phFriNfc_Tpz_H_RdBytes(phFriNfc_NdefMap_t *NdefMap,
\r
895 NFCSTATUS Result = NFCSTATUS_SUCCESS;
\r
896 #ifdef TOPAZ_RAW_SUPPORT
\r
898 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
900 /* set the data for additional data exchange*/
\r
901 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_TOPAZ_VAL0;
\r
902 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_TOPAZ_VAL0;
\r
903 NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_TOPAZ_VAL0;
\r
905 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_TopazMap_Process;
\r
906 NdefMap->MapCompletionInfo.Context = NdefMap;
\r
908 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
\r
910 /* Depending on the jewel command, the send length is decided */
\r
911 #ifdef TOPAZ_RAW_SUPPORT
\r
912 switch(NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0])
\r
914 switch(NdefMap->Cmd.JewelCmd)
\r
915 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
918 #ifdef TOPAZ_RAW_SUPPORT
\r
919 case PH_FRINFC_TOPAZ_CMD_READID:
\r
921 #ifdef PH_HAL4_ENABLE
\r
922 case phHal_eJewel_RID:
\r
924 case phHal_eJewelCmdListJewelRid:
\r
926 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
928 #ifdef TOPAZ_RAW_SUPPORT
\r
929 NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
\r
930 /*Copy command to Send Buffer*/
\r
931 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = PH_FRINFC_TOPAZ_CMD_READID;
\r
934 /*Copy UID of the tag to Send Buffer*/
\r
935 (void)memset(&(NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL1]),
\r
937 index = index + 0x06;
\r
939 /* Update the length of the command buffer*/
\r
940 NdefMap->SendLength = index;
\r
942 /* For READ ID and READ ALL, send length is 0 */
\r
943 NdefMap->SendLength = PH_FRINFC_TOPAZ_VAL0;
\r
944 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
947 #ifdef TOPAZ_RAW_SUPPORT
\r
948 case PH_FRINFC_TOPAZ_CMD_READALL:
\r
950 #ifdef PH_HAL4_ENABLE
\r
951 case phHal_eJewel_ReadAll:
\r
953 case phHal_eJewelCmdListJewelReadAll:
\r
955 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
957 #ifdef TOPAZ_RAW_SUPPORT
\r
958 NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
\r
959 /*Copy command to Send Buffer*/
\r
960 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = PH_FRINFC_TOPAZ_CMD_READALL;
\r
963 /*Copy 0x00 to Send Buffer*/
\r
964 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL1] = 0x00;
\r
966 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2] = 0x00;
\r
969 /*Copy UID of the tag to Send Buffer*/
\r
970 (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL3]),
\r
971 &(NdefMap->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid),
\r
972 TOPAZ_UID_LENGTH_FOR_READ_WRITE);
\r
974 index = (uint8_t)(index + TOPAZ_UID_LENGTH_FOR_READ_WRITE);
\r
976 /* Update the length of the command buffer*/
\r
977 NdefMap->SendLength = index;
\r
979 /* For READ ID and READ ALL, send length is 0 */
\r
980 NdefMap->SendLength = PH_FRINFC_TOPAZ_VAL0;
\r
981 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
984 #ifdef TOPAZ_RAW_SUPPORT
\r
985 case PH_FRINFC_TOPAZ_CMD_READ:
\r
987 #ifdef PH_HAL4_ENABLE
\r
988 case phHal_eJewel_Read1:
\r
990 case phHal_eJewelCmdListJewelRead1:
\r
993 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
995 #ifdef TOPAZ_RAW_SUPPORT
\r
996 NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
\r
997 /*Copy command to Send Buffer*/
\r
998 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = PH_FRINFC_TOPAZ_CMD_READ;
\r
1001 /*Copy Address to Send Buffer*/
\r
1002 /* Calculate send length
\r
1003 7 | 6 5 4 3 | 2 1 0 |
\r
1004 | block no | byte no |
\r
1006 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL1] =
\r
1007 (uint8_t)((BlockNo << PH_FRINFC_TOPAZ_SHIFT3) +
\r
1010 /*Copy 0x00 to Send Buffer*/
\r
1011 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2] = 0x00;
\r
1014 /*Copy UID of the tag to Send Buffer*/
\r
1015 (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL3]),
\r
1016 &(NdefMap->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid),
\r
1017 TOPAZ_UID_LENGTH_FOR_READ_WRITE);
\r
1018 index = (uint8_t)(index + TOPAZ_UID_LENGTH_FOR_READ_WRITE);
\r
1020 /* Update the length of the command buffer*/
\r
1021 NdefMap->SendLength = index;
\r
1023 /* Calculate send length
\r
1024 7 | 6 5 4 3 | 2 1 0 |
\r
1025 | block no | byte no |
\r
1027 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] =
\r
1028 (uint8_t)((BlockNo << PH_FRINFC_TOPAZ_SHIFT3) +
\r
1030 NdefMap->SendLength = PH_FRINFC_TOPAZ_VAL1;
\r
1031 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
1034 #ifdef TOPAZ_RAW_SUPPORT
\r
1036 #ifdef PH_HAL4_ENABLE
\r
1037 case phHal_eJewel_Read:
\r
1038 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = 0x00;
\r
1039 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL1] = 0x00;
\r
1040 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2] = 104;
\r
1041 NdefMap->SendLength = 3;
\r
1044 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
1047 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1048 NFCSTATUS_INVALID_DEVICE_REQUEST);
\r
1051 if(Result == NFCSTATUS_SUCCESS)
\r
1053 /* Call the Overlapped HAL Transceive function */
\r
1054 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice,
\r
1055 &NdefMap->MapCompletionInfo,
\r
1056 NdefMap->psRemoteDevInfo,
\r
1058 &NdefMap->psDepAdditionalInfo,
\r
1059 NdefMap->SendRecvBuf,
\r
1060 NdefMap->SendLength,
\r
1061 NdefMap->SendRecvBuf,
\r
1062 NdefMap->SendRecvLength);
\r
1067 static NFCSTATUS phFriNfc_Tpz_H_WrAByte(phFriNfc_NdefMap_t *NdefMap,
\r
1073 NFCSTATUS Result = NFCSTATUS_SUCCESS;
\r
1074 uint8_t index = 0;
\r
1077 PHNFC_UNUSED_VARIABLE(ByteVal);
\r
1078 /* set the data for additional data exchange*/
\r
1079 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_TOPAZ_VAL0;
\r
1080 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_TOPAZ_VAL0;
\r
1081 NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_TOPAZ_VAL0;
\r
1083 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_TopazMap_Process;
\r
1084 NdefMap->MapCompletionInfo.Context = NdefMap;
\r
1086 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
\r
1087 /* Command used to write 1 byte */
\r
1088 #ifdef TOPAZ_RAW_SUPPORT
\r
1089 NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
\r
1091 #ifdef PH_HAL4_ENABLE
\r
1092 NdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
\r
1094 NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelWriteErase1;
\r
1096 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
1098 #ifdef TOPAZ_RAW_SUPPORT
\r
1099 /*Copy command to Send Buffer*/
\r
1100 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = PH_FRINFC_TOPAZ_CMD_WRITE_1E;
\r
1103 /*Copy Address to Send Buffer*/
\r
1104 /* Calculate send length
\r
1105 7 | 6 5 4 3 | 2 1 0 |
\r
1106 | block no | byte no |
\r
1108 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL1] =
\r
1109 (uint8_t)((BlockNo << PH_FRINFC_TOPAZ_SHIFT3) +
\r
1112 /*Copy Data byte to Send Buffer*/
\r
1113 NdefMap->SendRecvBuf[index] = ByteVal;
\r
1116 /*Copy UID of the tag to Send Buffer*/
\r
1117 (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL3]),
\r
1118 &(NdefMap->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid),
\r
1119 TOPAZ_UID_LENGTH_FOR_READ_WRITE);
\r
1120 index = (uint8_t)(index + TOPAZ_UID_LENGTH_FOR_READ_WRITE);
\r
1122 /* Update the length of the command buffer*/
\r
1123 NdefMap->SendLength = index;
\r
1126 /* Depending on the jewel command, the send length is decided */
\r
1127 /* Calculate send length
\r
1128 7 | 6 5 4 3 | 2 1 0 |
\r
1129 | block no | byte no |
\r
1131 NdefMap->SendRecvBuf[index] =
\r
1132 (uint8_t)((BlockNo << PH_FRINFC_TOPAZ_SHIFT3) +
\r
1135 NdefMap->SendRecvBuf[index] = ByteVal;
\r
1137 NdefMap->SendLength = PH_FRINFC_TOPAZ_VAL2;
\r
1139 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
1141 /* Call the Overlapped HAL Transceive function */
\r
1142 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice,
\r
1143 &NdefMap->MapCompletionInfo,
\r
1144 NdefMap->psRemoteDevInfo,
\r
1146 &NdefMap->psDepAdditionalInfo,
\r
1147 NdefMap->SendRecvBuf,
\r
1148 NdefMap->SendLength,
\r
1149 NdefMap->SendRecvBuf,
\r
1150 NdefMap->SendRecvLength);
\r
1155 static NFCSTATUS phFriNfc_Tpz_H_ProReadID(phFriNfc_NdefMap_t *NdefMap)
\r
1157 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1158 NFCSTATUS_INVALID_RECEIVE_LENGTH);
\r
1160 if(((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] &
\r
1161 PH_FRINFC_TOPAZ_HEADROM0_CHK) == PH_FRINFC_TOPAZ_HEADROM0_VAL) &&
\r
1162 (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL6))
\r
1164 /* Copy UID to the context, Used when the READ ALL command is used */
\r
1165 (void)memcpy(NdefMap->TopazContainer.UID,
\r
1166 &NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2],
\r
1167 PH_FRINFC_TOPAZ_VAL4);
\r
1169 /* State has to be changed */
\r
1170 NdefMap->State = PH_FRINFC_TOPAZ_STATE_READALL;
\r
1171 /* Topaz command = READALL */
\r
1172 #ifdef TOPAZ_RAW_SUPPORT
\r
1173 NdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
\r
1174 NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] = PH_FRINFC_TOPAZ_CMD_READALL;
\r
1176 #ifdef PH_HAL4_ENABLE
\r
1177 NdefMap->Cmd.JewelCmd = phHal_eJewel_ReadAll;
\r
1179 NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelReadAll;
\r
1181 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
\r
1183 /* Read all bytes from the card */
\r
1184 Result = phFriNfc_Tpz_H_RdBytes(NdefMap, NdefMap->TopazContainer.CurrentBlock,
\r
1185 NdefMap->TopazContainer.ByteNumber);
\r
1191 static NFCSTATUS phFriNfc_Tpz_H_ProReadAll(phFriNfc_NdefMap_t *NdefMap)
\r
1193 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1194 NFCSTATUS_INVALID_RECEIVE_LENGTH);
\r
1195 int32_t memcompare = PH_FRINFC_TOPAZ_VAL0;
\r
1197 /* Compare the UID of READ ALL command with the stored UID */
\r
1198 #ifdef PH_HAL4_ENABLE
\r
1199 if ((NdefMap->TopazContainer.UID[0] == NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2]) &&
\r
1200 (NdefMap->TopazContainer.UID[1] == NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2 + 1]) &&
\r
1201 (NdefMap->TopazContainer.UID[2] == NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2 + 2]) &&
\r
1202 (NdefMap->TopazContainer.UID[3] == NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2 + 3]))
\r
1204 memcompare = PH_FRINFC_TOPAZ_VAL0;
\r
1208 memcompare = PH_FRINFC_TOPAZ_VAL1;
\r
1211 memcompare = memcmp(NdefMap->TopazContainer.UID,
\r
1212 &NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2],
\r
1213 PH_FRINFC_TOPAZ_VAL4);
\r
1214 #endif /* #ifdef PH_HAL4_ENABLE */
\r
1216 if(((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] &
\r
1217 PH_FRINFC_TOPAZ_HEADROM0_CHK) == PH_FRINFC_TOPAZ_HEADROM0_VAL) &&
\r
1218 (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_READALL_RESP) &&
\r
1219 (memcompare == PH_FRINFC_TOPAZ_VAL0))
\r
1221 /* Copy 96 bytes from the read/write memory space */
\r
1222 (void)memcpy(NdefMap->TopazContainer.ReadBuffer,
\r
1223 &NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL10],
\r
1224 PH_FRINFC_TOPAZ_TOTAL_RWBYTES);
\r
1226 /* Check the lock bits and set the card state */
\r
1227 phFriNfc_Tpz_H_ChkLockBits(NdefMap);
\r
1229 Result = phFriNfc_Tpz_H_CallNxtOp(NdefMap);
\r
1234 static NFCSTATUS phFriNfc_Tpz_H_CallNxtOp(phFriNfc_NdefMap_t *NdefMap)
\r
1236 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1237 NFCSTATUS_INVALID_RECEIVE_LENGTH);
\r
1238 /* Depending on the operation (check, read or write ndef), process the
\r
1240 switch(NdefMap->PrevOperation)
\r
1242 case PH_FRINFC_NDEFMAP_CHECK_OPE:
\r
1243 /* Check the capabilty container values, according
\r
1245 Result = phFriNfc_Tpz_H_ChkCCinChkNdef(NdefMap);
\r
1247 if (NdefMap->CardState != PH_NDEFMAP_CARD_STATE_INVALID)
\r
1249 /* Check the spec version */
\r
1250 Result = phFriNfc_Tpz_H_ChkSpcVer( NdefMap,
\r
1251 NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL1]);
\r
1252 /* Check the CC header size: Only valid ones are
\r
1253 0x0C for 96 bytes. */
\r
1254 if ((Result == NFCSTATUS_SUCCESS) &&
\r
1255 ( NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL2] <=
\r
1256 PH_FRINFC_TOPAZ_CC_BYTE2_MAX))
\r
1258 Result = phFriNfc_Tpz_H_findNDEFTLV(NdefMap);
\r
1259 /* As there is possibility of either having or not having TLV in
\r
1260 Topaz, no need to send the Actual status to the context*/
\r
1261 Result = NFCSTATUS_SUCCESS;
\r
1266 Result = NFCSTATUS_SUCCESS;
\r
1267 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED;
\r
1268 NdefMap->CardMemSize =
\r
1269 NdefMap->TopazContainer.RemainingSize = (uint16_t)
\r
1271 4 is decremented from the max size because of the 4 CC bytes
\r
1272 2 is decremented because of the NDEF TLV T and L byte
\r
1273 to get the actual data size
\r
1275 (PH_FRINFC_TOPAZ_MAX_CARD_SZ - PH_FRINFC_TOPAZ_VAL4 -
\r
1276 PH_FRINFC_TOPAZ_VAL2);
\r
1280 case PH_FRINFC_NDEFMAP_READ_OPE:
\r
1281 /* Check the capabilty container values, according
\r
1283 Result = phFriNfc_Tpz_H_ChkCCBytes(NdefMap);
\r
1285 /* If success, find the ndef TLV */
\r
1286 Result = ((Result != NFCSTATUS_SUCCESS)?
\r
1287 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1288 NFCSTATUS_INVALID_FORMAT)):
\r
1289 phFriNfc_Tpz_H_findNDEFTLV(NdefMap));
\r
1291 if(Result == NFCSTATUS_SUCCESS)
\r
1293 NdefMap->TopazContainer.ByteNumber += PH_FRINFC_TOPAZ_VAL2;
\r
1294 /* If success, copy the read bytes to the user buffer */
\r
1295 Result = phFriNfc_Tpz_H_CpDataToUsrBuf(NdefMap);
\r
1299 case PH_FRINFC_NDEFMAP_WRITE_OPE:
\r
1301 if((NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_WRITE) ||
\r
1302 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INITIALIZED))
\r
1304 /* Check the capabilty container values, according
\r
1306 Result = phFriNfc_Tpz_H_ChkCCBytes(NdefMap);
\r
1307 if(Result == NFCSTATUS_SUCCESS)
\r
1309 /* Find the NDEF TLV */
\r
1310 Result = phFriNfc_Tpz_H_findNDEFTLV(NdefMap);
\r
1312 /* Write the TLV */
\r
1313 NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_T_OF_TLV;
\r
1317 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_TOPAZ_VAL4;
\r
1318 NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_TOPAZ_VAL1;
\r
1319 NdefMap->TopazContainer.ByteNumber = PH_FRINFC_TOPAZ_VAL4;
\r
1320 /* Write the TLV */
\r
1321 NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_CC_BYTE0;
\r
1323 /* Write CC bytes */
\r
1324 Result = phFriNfc_Tpz_H_WrCCorTLV(NdefMap);
\r
1331 static NFCSTATUS phFriNfc_Tpz_H_ChkCCBytes(phFriNfc_NdefMap_t *NdefMap)
\r
1333 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1334 NFCSTATUS_NO_NDEF_SUPPORT);
\r
1336 if(NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL0] ==
\r
1337 PH_FRINFC_TOPAZ_CC_BYTE0)
\r
1339 /* Check the spec version */
\r
1340 Result = phFriNfc_Tpz_H_ChkSpcVer( NdefMap,
\r
1341 NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL1]);
\r
1342 /* Check the CC header size: Only valid ones are
\r
1343 0x0C for 96 bytes. */
\r
1344 Result = ((( NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL2] >
\r
1345 PH_FRINFC_TOPAZ_CC_BYTE2_MAX) || (Result !=
\r
1346 NFCSTATUS_SUCCESS))?
\r
1347 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1348 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED)):
\r
1351 /* Get the read/write card memory size */
\r
1352 NdefMap->TopazContainer.RemainingSize =
\r
1353 NdefMap->CardMemSize = ((Result == NFCSTATUS_SUCCESS)?
\r
1354 (PH_FRINFC_TOPAZ_MAX_CARD_SZ - PH_FRINFC_TOPAZ_VAL4):
\r
1355 NdefMap->CardMemSize);
\r
1357 /* if the call is from write ndef then check for read write access */
\r
1358 if(((NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_WRITE_OPE) &&
\r
1359 (NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL3] !=
\r
1360 PH_FRINFC_TOPAZ_CC_BYTE3_RW) && (Result == NFCSTATUS_SUCCESS)))
\r
1362 Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1363 NFCSTATUS_INVALID_FORMAT));
\r
1366 /* if the call is from read ndef then check for read only or read write access */
\r
1367 if(((NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE) &&
\r
1368 ((NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL3] !=
\r
1369 PH_FRINFC_TOPAZ_CC_BYTE3_RW) &&
\r
1370 (NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL3] !=
\r
1371 PH_FRINFC_TOPAZ_CC_BYTE3_RO))&& (Result == NFCSTATUS_SUCCESS)))
\r
1373 Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1374 NFCSTATUS_INVALID_FORMAT));
\r
1380 extern NFCSTATUS phFriNfc_Tpz_H_ChkSpcVer( phFriNfc_NdefMap_t *NdefMap,
\r
1381 uint8_t VersionNo)
\r
1383 NFCSTATUS Result = NFCSTATUS_SUCCESS;
\r
1384 uint8_t TagVerNo = VersionNo;
\r
1386 /* To remove "warning (VS C4100) : unreferenced formal parameter" */
\r
1387 PHNFC_UNUSED_VARIABLE(NdefMap);
\r
1389 if ( TagVerNo == 0 )
\r
1391 /*Return Status Error
\93 Invalid Format
\94*/
\r
1392 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,NFCSTATUS_INVALID_FORMAT);
\r
1396 /* calculate the major and minor version number of T3VerNo */
\r
1397 if( (( PH_NFCFRI_NDEFMAP_NFCDEV_MAJOR_VER_NUM ==
\r
1398 PH_NFCFRI_NDEFMAP_GET_MAJOR_TAG_VERNO(TagVerNo ) )&&
\r
1399 ( PH_NFCFRI_NDEFMAP_NFCDEV_MINOR_VER_NUM >=
\r
1400 PH_NFCFRI_NDEFMAP_GET_MINOR_TAG_VERNO(TagVerNo))) ||
\r
1401 (( PH_NFCFRI_NDEFMAP_NFCDEV_MAJOR_VER_NUM ==
\r
1402 PH_NFCFRI_NDEFMAP_GET_MAJOR_TAG_VERNO(TagVerNo ) )&&
\r
1403 ( PH_NFCFRI_NDEFMAP_NFCDEV_MINOR_VER_NUM <
\r
1404 PH_NFCFRI_NDEFMAP_GET_MINOR_TAG_VERNO(TagVerNo) )))
\r
1406 Result = PHNFCSTVAL(CID_NFC_NONE,NFCSTATUS_SUCCESS);
\r
1410 if (( PH_NFCFRI_NDEFMAP_NFCDEV_MAJOR_VER_NUM <
\r
1411 PH_NFCFRI_NDEFMAP_GET_MAJOR_TAG_VERNO(TagVerNo) ) ||
\r
1412 ( PH_NFCFRI_NDEFMAP_NFCDEV_MAJOR_VER_NUM >
\r
1413 PH_NFCFRI_NDEFMAP_GET_MAJOR_TAG_VERNO(TagVerNo)))
\r
1415 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,NFCSTATUS_INVALID_FORMAT);
\r
1422 static NFCSTATUS phFriNfc_Tpz_H_findNDEFTLV(phFriNfc_NdefMap_t *NdefMap)
\r
1424 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1425 NFCSTATUS_NO_NDEF_SUPPORT);
\r
1426 uint8_t index = PH_FRINFC_TOPAZ_VAL4;
\r
1428 /* If remaining size is less than 3 then, there cant be any
\r
1429 TLV present in the card */
\r
1430 while((index < PH_FRINFC_TOPAZ_TOTAL_RWBYTES) &&
\r
1431 (NdefMap->TopazContainer.RemainingSize >= PH_FRINFC_TOPAZ_VAL3))
\r
1433 switch(NdefMap->TopazContainer.ReadBuffer[index])
\r
1435 case PH_FRINFC_TOPAZ_NDEF_T:
\r
1436 /* To get the length field of the TLV */
\r
1438 /* Type and length are not data bytes, so to know the exact
\r
1439 remaining size in the card, the below operation is done */
\r
1440 NdefMap->TopazContainer.RemainingSize -= PH_FRINFC_TOPAZ_VAL2;
\r
1441 /* Set the card state depending on the L value */
\r
1442 Result = phFriNfc_MapTool_SetCardState(NdefMap,
\r
1443 (uint32_t)NdefMap->TopazContainer.ReadBuffer[index]);
\r
1444 /* Check the TLV is correct */
\r
1445 if((NdefMap->TopazContainer.ReadBuffer[index] >
\r
1446 NdefMap->TopazContainer.RemainingSize) ||
\r
1447 ((NdefMap->TopazContainer.ReadBuffer[index] ==
\r
1448 PH_FRINFC_TOPAZ_VAL0) && (NdefMap->PrevOperation ==
\r
1449 PH_FRINFC_NDEFMAP_READ_OPE)) || (Result != NFCSTATUS_SUCCESS))
\r
1451 /* L field value cant be greater than the remaining size, so error */
\r
1452 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1453 NFCSTATUS_NO_NDEF_SUPPORT);
\r
1454 /* To break out of the loop */
\r
1455 index = PH_FRINFC_TOPAZ_TOTAL_RWBYTES;
\r
1459 /* So remaining size also changes, according to the position of NDEF TLV */
\r
1460 NdefMap->TLVStruct.BytesRemainLinTLV =
\r
1461 NdefMap->TopazContainer.ReadBuffer[index];
\r
1463 /* Get the byte number */
\r
1464 NdefMap->TLVStruct.NdefTLVByte = (uint16_t)((index - PH_FRINFC_TOPAZ_VAL1) %
\r
1465 PH_FRINFC_TOPAZ_VAL8);
\r
1466 /* Get the block number */
\r
1467 NdefMap->TLVStruct.NdefTLVBlock = (uint8_t)(((index - PH_FRINFC_TOPAZ_VAL1) /
\r
1468 PH_FRINFC_TOPAZ_VAL8) +
\r
1469 PH_FRINFC_TOPAZ_VAL1);
\r
1470 /* TLV found flag is set */
\r
1471 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_TOPAZ_FLAG1;
\r
1472 /* To know the position of V field in the TLV */
\r
1473 NdefMap->TopazContainer.ByteNumber = (uint8_t)(((NdefMap->TLVStruct.NdefTLVBlock - 1) * 8) +
\r
1474 NdefMap->TLVStruct.NdefTLVByte);
\r
1475 /* To break out of the loop */
\r
1476 index = PH_FRINFC_TOPAZ_TOTAL_RWBYTES;
\r
1477 Result = NFCSTATUS_SUCCESS;
\r
1481 case PH_FRINFC_TOPAZ_NULL_T:
\r
1482 /* Null TLV, Skip the TLV */
\r
1483 NdefMap->TopazContainer.RemainingSize--;
\r
1487 case PH_FRINFC_TOPAZ_TERM_T:
\r
1488 /* No more TLV present in the card, so error */
\r
1489 index = PH_FRINFC_TOPAZ_TOTAL_RWBYTES;
\r
1490 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1491 NFCSTATUS_NO_NDEF_SUPPORT);
\r
1495 /* Go till the length field of the TLV */
\r
1497 /* Type and length is not the data, so to know the exact
\r
1498 remaining size in the card, the below operation is done */
\r
1499 NdefMap->TopazContainer.RemainingSize -= PH_FRINFC_TOPAZ_VAL2;
\r
1500 if(NdefMap->TopazContainer.ReadBuffer[index] >
\r
1501 NdefMap->TopazContainer.RemainingSize)
\r
1503 /* L field value cant be greater than the remaining size, so error */
\r
1504 index = PH_FRINFC_TOPAZ_TOTAL_RWBYTES;
\r
1505 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1506 NFCSTATUS_NO_NDEF_SUPPORT);
\r
1510 /* Remaining size of the free space available in the card changes,
\r
1511 according to the position of NDEF TLV */
\r
1512 NdefMap->TopazContainer.RemainingSize =
\r
1513 NdefMap->TopazContainer.RemainingSize -
\r
1514 NdefMap->TopazContainer.ReadBuffer[index];
\r
1516 /* Get the position of the next TLV */
\r
1517 index = (uint8_t)(index +
\r
1518 (NdefMap->TopazContainer.ReadBuffer[index] +
\r
1519 PH_FRINFC_TOPAZ_VAL1));
\r
1525 /* If no Ndef TLV found and operation done is read */
\r
1526 if((NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_TOPAZ_FLAG0) &&
\r
1527 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE))
\r
1529 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1530 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
\r
1532 if((NdefMap->TLVStruct.NdefTLVFoundFlag == PH_FRINFC_TOPAZ_FLAG0) &&
\r
1533 ((NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_WRITE_OPE) ||
\r
1534 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_CHECK_OPE)))
\r
1536 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_TOPAZ_VAL4;
\r
1537 NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_TOPAZ_VAL1;
\r
1538 NdefMap->TopazContainer.ByteNumber = PH_FRINFC_TOPAZ_VAL4;
\r
1539 NdefMap->TopazContainer.RemainingSize = PH_FRINFC_TOPAZ_TOTAL_RWBYTES1;
\r
1544 static NFCSTATUS phFriNfc_Tpz_H_CpDataToUsrBuf(phFriNfc_NdefMap_t *NdefMap)
\r
1546 NFCSTATUS Result = NFCSTATUS_SUCCESS;
\r
1548 /* Check the the TLV size and the user size */
\r
1549 if(NdefMap->ApduBufferSize >=
\r
1550 NdefMap->TLVStruct.BytesRemainLinTLV)
\r
1552 /* Copy the read bytes to user buffer till the value (V)
\r
1554 (void)memcpy(NdefMap->ApduBuffer,
\r
1555 &(NdefMap->TopazContainer.ReadBuffer[
\r
1556 NdefMap->TopazContainer.ByteNumber]),
\r
1557 NdefMap->TLVStruct.BytesRemainLinTLV);
\r
1559 /* Update the number of read bytes to the user */
\r
1560 *(NdefMap->NumOfBytesRead) =
\r
1561 NdefMap->TLVStruct.BytesRemainLinTLV;
\r
1562 /* There is no byte to read */
\r
1563 NdefMap->TopazContainer.ByteNumber =
\r
1564 PH_FRINFC_TOPAZ_VAL0;
\r
1565 /* No further read is possible */
\r
1566 NdefMap->TopazContainer.ReadWriteCompleteFlag =
\r
1567 PH_FRINFC_TOPAZ_FLAG1;
\r
1568 /* Remaining size in the card can be greater than length field in
\r
1570 NdefMap->TopazContainer.RemainingSize =
\r
1571 NdefMap->TopazContainer.RemainingSize -
\r
1572 NdefMap->TLVStruct.BytesRemainLinTLV;
\r
1573 /* TLV has been completely read, no more bytes to read */
\r
1574 NdefMap->TLVStruct.BytesRemainLinTLV =
\r
1575 PH_FRINFC_TOPAZ_VAL0;
\r
1579 /* Copy read bytes till the user buffer size */
\r
1580 (void)memcpy(NdefMap->ApduBuffer,
\r
1581 &(NdefMap->TopazContainer.ReadBuffer[
\r
1582 NdefMap->TopazContainer.ByteNumber]),
\r
1583 NdefMap->ApduBufferSize);
\r
1585 /* Update the number of read bytes to the user */
\r
1586 *(NdefMap->NumOfBytesRead) =
\r
1587 NdefMap->ApduBufferSize;
\r
1588 /* Get the next byte number to read */
\r
1589 NdefMap->TopazContainer.ByteNumber =
\r
1590 (uint8_t)(NdefMap->TopazContainer.ByteNumber +
\r
1591 NdefMap->ApduBufferSize);
\r
1592 /* Free space left in the card */
\r
1593 NdefMap->TopazContainer.RemainingSize
\r
1594 = NdefMap->TopazContainer.RemainingSize
\r
1595 - (uint16_t)NdefMap->ApduBufferSize;
\r
1596 /* Bytes left in the TLV */
\r
1597 NdefMap->TLVStruct.BytesRemainLinTLV =
\r
1598 NdefMap->TLVStruct.BytesRemainLinTLV -
\r
1599 (uint16_t)NdefMap->ApduBufferSize;
\r
1604 static NFCSTATUS phFriNfc_Tpz_H_ProWrNMN(phFriNfc_NdefMap_t *NdefMap)
\r
1606 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1607 NFCSTATUS_INVALID_RECEIVE_LENGTH);
\r
1608 uint8_t BlockNo = PH_FRINFC_TOPAZ_VAL0,
\r
1609 ByteNo = PH_FRINFC_TOPAZ_VAL0;
\r
1611 if((NdefMap->TopazContainer.InternalState ==
\r
1612 PH_FRINFC_TOPAZ_WR_NMN_0) &&
\r
1613 (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] ==
\r
1614 PH_FRINFC_TOPAZ_VAL0) &&
\r
1615 (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
\r
1617 NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE_L_TLV;
\r
1618 /* Get the L field of the TLV block */
\r
1619 BlockNo = (uint8_t)(((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_TOPAZ_VAL1) >
\r
1620 PH_FRINFC_TOPAZ_VAL7)?
\r
1621 (NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_TOPAZ_VAL1):
\r
1622 NdefMap->TLVStruct.NdefTLVBlock);
\r
1623 /* Get the L byte */
\r
1624 ByteNo = (uint8_t)((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_TOPAZ_VAL1) %
\r
1625 PH_FRINFC_TOPAZ_VAL8);
\r
1628 /* Here the NMN is written 0, so internal state is used */
\r
1629 NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_L_TLV_0;
\r
1630 /* Write the length value = 0x00 , Write L field of TLV = 0 inside this*/
\r
1631 Result = phFriNfc_Tpz_H_WrAByte( NdefMap, BlockNo, ByteNo,
\r
1632 PH_FRINFC_TOPAZ_VAL0);
\r
1636 if((NdefMap->TopazContainer.InternalState ==
\r
1637 PH_FRINFC_TOPAZ_WR_NMN_E1) &&
\r
1638 (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] ==
\r
1639 PH_FRINFC_TOPAZ_CC_BYTE0) &&
\r
1640 (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
\r
1642 /* Card state is initialised or invalid */
\r
1643 NdefMap->CardState = (uint8_t)((NdefMap->CardState ==
\r
1644 PH_NDEFMAP_CARD_STATE_INITIALIZED)?
\r
1645 PH_NDEFMAP_CARD_STATE_READ_WRITE:
\r
1646 NdefMap->CardState);
\r
1647 /* update the length to the user */
\r
1648 *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex;
\r
1649 Result = NFCSTATUS_SUCCESS;
\r
1655 static NFCSTATUS phFriNfc_Tpz_H_ProWrTLV(phFriNfc_NdefMap_t *NdefMap)
\r
1657 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1658 NFCSTATUS_INVALID_RECEIVE_LENGTH);
\r
1659 if((NdefMap->TopazContainer.InternalState ==
\r
1660 PH_FRINFC_TOPAZ_WR_L_TLV_0) &&
\r
1661 (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] ==
\r
1662 PH_FRINFC_TOPAZ_VAL0) &&
\r
1663 (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
\r
1665 /* state is writing user data to the card */
\r
1666 NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE;
\r
1668 NdefMap->TopazContainer.ByteNumber++;
\r
1669 /* Check the byte number */
\r
1670 phFriNfc_Tpz_H_BlkChk(NdefMap);
\r
1672 /* Write data to the specified location */
\r
1673 /* Write the data to the card from the user buffer */
\r
1674 Result = phFriNfc_Tpz_H_WrAByte( NdefMap,
\r
1675 NdefMap->TopazContainer.CurrentBlock,
\r
1676 NdefMap->TopazContainer.ByteNumber,
\r
1677 NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]
\r
1682 if((NdefMap->TopazContainer.InternalState ==
\r
1683 PH_FRINFC_TOPAZ_WR_L_TLV) &&
\r
1684 (((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) &&
\r
1685 (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] ==
\r
1686 NdefMap->ApduBuffIndex)) ||
\r
1687 ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&
\r
1688 (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] ==
\r
1689 (NdefMap->ApduBuffIndex + NdefMap->TLVStruct.BytesRemainLinTLV)))) &&
\r
1690 (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
\r
1692 /* Update the L value in the context */
\r
1693 NdefMap->TLVStruct.BytesRemainLinTLV =
\r
1694 ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
\r
1695 NdefMap->ApduBuffIndex:
\r
1696 (NdefMap->TLVStruct.BytesRemainLinTLV + NdefMap->ApduBuffIndex));
\r
1698 /* Write 0xE1 in block number = 1 and byte number = 0 */
\r
1699 Result = phFriNfc_Tpz_H_WrByte0ValE1(NdefMap);
\r
1705 static NFCSTATUS phFriNfc_Tpz_H_ProWrUsrData(phFriNfc_NdefMap_t *NdefMap)
\r
1707 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1708 NFCSTATUS_INVALID_RECEIVE_LENGTH);
\r
1709 /* send buffer should be equal to receive buffer */
\r
1710 if((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] ==
\r
1711 NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]) &&
\r
1712 (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
\r
1714 /* Increment the index */
\r
1715 NdefMap->ApduBuffIndex += PH_FRINFC_TOPAZ_VAL1;
\r
1717 /* Remaining space left in the card is less by one */
\r
1718 NdefMap->TopazContainer.RemainingSize -= PH_FRINFC_TOPAZ_VAL1;
\r
1720 /* Increment the byte number */
\r
1721 NdefMap->TopazContainer.ByteNumber++;
\r
1723 /* Check the block number */
\r
1724 phFriNfc_Tpz_H_BlkChk(NdefMap);
\r
1726 /* check for the user space or the card size */
\r
1727 if((NdefMap->ApduBufferSize == NdefMap->ApduBuffIndex) ||
\r
1728 (NdefMap->TopazContainer.RemainingSize == PH_FRINFC_TOPAZ_VAL0))
\r
1730 /* Set write complete, if the end of card is reached */
\r
1731 NdefMap->TopazContainer.ReadWriteCompleteFlag = (uint8_t)
\r
1732 ((NdefMap->TopazContainer.RemainingSize == PH_FRINFC_TOPAZ_VAL0)?
\r
1733 PH_FRINFC_TOPAZ_FLAG1:PH_FRINFC_TOPAZ_FLAG0);
\r
1735 Result = phFriNfc_Tpz_H_WrLByte(NdefMap);
\r
1739 /* State is continued to be in write */
\r
1740 NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE;
\r
1742 /* Write the byte to the specified location , and Byte to write */
\r
1743 Result = phFriNfc_Tpz_H_WrAByte(NdefMap, NdefMap->TopazContainer.CurrentBlock,
\r
1744 NdefMap->TopazContainer.ByteNumber,
\r
1745 NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]
\r
1752 static NFCSTATUS phFriNfc_Tpz_H_WrLByte(phFriNfc_NdefMap_t *NdefMap)
\r
1754 NFCSTATUS Result = NFCSTATUS_SUCCESS;
\r
1755 uint8_t BlockNo = PH_FRINFC_TOPAZ_VAL0,
\r
1756 ByteNo = PH_FRINFC_TOPAZ_VAL0;
\r
1757 uint8_t TempByteVal = 0;
\r
1758 BlockNo = (uint8_t)(((NdefMap->TLVStruct.NdefTLVByte +
\r
1759 PH_FRINFC_TOPAZ_VAL1) >
\r
1760 PH_FRINFC_TOPAZ_VAL7)?
\r
1761 (NdefMap->TLVStruct.NdefTLVBlock +
\r
1762 PH_FRINFC_TOPAZ_VAL1):
\r
1763 NdefMap->TLVStruct.NdefTLVBlock);
\r
1765 ByteNo = (uint8_t)((NdefMap->TLVStruct.NdefTLVByte +
\r
1766 PH_FRINFC_TOPAZ_VAL1) % PH_FRINFC_TOPAZ_VAL8);
\r
1767 /* Update L field */
\r
1768 NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE_L_TLV;
\r
1769 /* Internal state for write */
\r
1770 NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_L_TLV;
\r
1771 /* Update the length field depending on the offset */
\r
1772 TempByteVal = (uint8_t)
\r
1773 ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
\r
1774 NdefMap->ApduBuffIndex:
\r
1775 (NdefMap->ApduBuffIndex +
\r
1776 NdefMap->TLVStruct.BytesRemainLinTLV));
\r
1777 /* Write the L field */
\r
1778 Result = phFriNfc_Tpz_H_WrAByte(NdefMap, BlockNo, ByteNo,TempByteVal);
\r
1782 static NFCSTATUS phFriNfc_Tpz_H_WrByte0ValE1(phFriNfc_NdefMap_t *NdefMap)
\r
1784 NFCSTATUS Result = NFCSTATUS_SUCCESS;
\r
1786 /* Update L field */
\r
1787 NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE_NMN;
\r
1788 /* Internal state for writing 0xE1 */
\r
1789 NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_NMN_E1;
\r
1790 /* Update the length field depending on the offset */
\r
1791 /* Write the L field */
\r
1792 Result = phFriNfc_Tpz_H_WrAByte(NdefMap, PH_FRINFC_TOPAZ_VAL1,
\r
1793 PH_FRINFC_TOPAZ_VAL0,PH_FRINFC_TOPAZ_CC_BYTE0);
\r
1797 static void phFriNfc_Tpz_H_Complete(phFriNfc_NdefMap_t *NdefMap,
\r
1800 /* set the state back to the Reset_Init state*/
\r
1801 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RESET_INIT;
\r
1803 /* set the completion routine*/
\r
1804 NdefMap->CompletionRoutine[NdefMap->TopazContainer.CRIndex].
\r
1805 CompletionRoutine(NdefMap->CompletionRoutine->Context, Status);
\r
1808 static void phFriNfc_Tpz_H_BlkChk(phFriNfc_NdefMap_t *NdefMap)
\r
1810 NdefMap->TopazContainer.CurrentBlock =
\r
1811 (uint8_t)((NdefMap->TopazContainer.ByteNumber >
\r
1812 PH_FRINFC_TOPAZ_VAL7)?
\r
1813 (NdefMap->TopazContainer.CurrentBlock +
\r
1814 PH_FRINFC_TOPAZ_VAL1):
\r
1815 NdefMap->TopazContainer.CurrentBlock);
\r
1817 NdefMap->TopazContainer.ByteNumber = (uint8_t)(NdefMap->TopazContainer.ByteNumber %
\r
1818 PH_FRINFC_TOPAZ_VAL8);
\r
1821 static NFCSTATUS phFriNfc_Tpz_H_ChkCCinChkNdef(phFriNfc_NdefMap_t *NdefMap)
\r
1823 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1824 NFCSTATUS_NO_NDEF_SUPPORT);
\r
1826 if(NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL0] ==
\r
1827 PH_FRINFC_TOPAZ_CC_BYTE0)
\r
1829 /* Check the most significant nibble of byte 3 (RWA) = 0 */
\r
1830 Result = (((NdefMap->TopazContainer.ReadBuffer[PH_FRINFC_TOPAZ_VAL3] &
\r
1831 PH_FRINFC_TOPAZ_BYTE3_MSB)== PH_FRINFC_TOPAZ_VAL0)?
\r
1832 NFCSTATUS_SUCCESS:
\r
1835 /* Card size is initialised */
\r
1836 NdefMap->CardMemSize = NdefMap->TopazContainer.RemainingSize =
\r
1837 ((Result == NFCSTATUS_SUCCESS)?
\r
1838 (PH_FRINFC_TOPAZ_MAX_CARD_SZ - PH_FRINFC_TOPAZ_VAL4):
\r
1839 NdefMap->CardMemSize);
\r
1842 if (NdefMap->CardState != PH_NDEFMAP_CARD_STATE_READ_ONLY)
\r
1844 NdefMap->CardState = (uint8_t)((Result == NFCSTATUS_SUCCESS)?
\r
1845 PH_NDEFMAP_CARD_STATE_INITIALIZED:
\r
1846 PH_NDEFMAP_CARD_STATE_INVALID);
\r
1852 static void phFriNfc_Tpz_H_ChkLockBits(phFriNfc_NdefMap_t *NdefMap)
\r
1854 /* Set the card state */
\r
1855 NdefMap->CardState = (uint8_t)
\r
1856 (((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_LOCKBIT_BYTENO_0] ==
\r
1857 PH_FRINFC_TOPAZ_LOCKBIT_BYTE114) &&
\r
1858 ((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_LOCKBIT_BYTENO_1] ==
\r
1859 PH_FRINFC_TOPAZ_LOCKBIT_BYTE115_1) ||
\r
1860 (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_LOCKBIT_BYTENO_1] ==
\r
1861 PH_FRINFC_TOPAZ_LOCKBIT_BYTE115_2)))?
\r
1862 PH_NDEFMAP_CARD_STATE_READ_WRITE:
\r
1863 PH_NDEFMAP_CARD_STATE_READ_ONLY);
\r
1865 /* Set the card state from CC bytes */
\r
1866 if (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_WRITE)
\r
1868 if (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_CC_BYTENO_3] == PH_FRINFC_TOPAZ_CC_READWRITE)
\r
1870 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_WRITE;
\r
1872 else if (NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_CC_BYTENO_3] == PH_FRINFC_TOPAZ_CC_READONLY)
\r
1874 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;
\r
1878 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
\r
1883 static NFCSTATUS phFriNfc_Tpz_H_WrCCorTLV(phFriNfc_NdefMap_t *NdefMap)
\r
1885 NFCSTATUS Result = NFCSTATUS_SUCCESS;
\r
1886 uint8_t ByteNo = PH_FRINFC_TOPAZ_VAL0,
\r
1887 BlockNo = PH_FRINFC_TOPAZ_VAL0;
\r
1888 uint8_t TempByteVal = 0;
\r
1889 switch(NdefMap->TopazContainer.InternalState)
\r
1891 case PH_FRINFC_TOPAZ_WR_CC_BYTE0:
\r
1892 /* To write the CC bytes */
\r
1893 TempByteVal = PH_FRINFC_TOPAZ_CC_BYTE0;
\r
1894 ByteNo = (uint8_t)PH_FRINFC_TOPAZ_VAL0;
\r
1895 BlockNo = PH_FRINFC_TOPAZ_VAL1;
\r
1898 case PH_FRINFC_TOPAZ_WR_CC_BYTE1:
\r
1899 /* To write the CC bytes */
\r
1900 TempByteVal = PH_FRINFC_TOPAZ_CC_BYTE1;
\r
1901 ByteNo = (uint8_t)PH_FRINFC_TOPAZ_VAL1;
\r
1902 BlockNo = PH_FRINFC_TOPAZ_VAL1;
\r
1905 case PH_FRINFC_TOPAZ_WR_CC_BYTE2:
\r
1906 /* To write the CC bytes */
\r
1907 TempByteVal = PH_FRINFC_TOPAZ_CC_BYTE2_MAX;
\r
1908 ByteNo = (uint8_t)PH_FRINFC_TOPAZ_VAL2;
\r
1909 BlockNo = PH_FRINFC_TOPAZ_VAL1;
\r
1912 case PH_FRINFC_TOPAZ_WR_CC_BYTE3:
\r
1913 /* To write the CC bytes */
\r
1914 TempByteVal = PH_FRINFC_TOPAZ_CC_BYTE3_RW;
\r
1915 ByteNo = (uint8_t)PH_FRINFC_TOPAZ_VAL3;
\r
1916 BlockNo = PH_FRINFC_TOPAZ_VAL1;
\r
1919 case PH_FRINFC_TOPAZ_WR_T_OF_TLV:
\r
1921 /* To write the NDEF TLV (if not present) */
\r
1922 TempByteVal = PH_FRINFC_TOPAZ_NDEF_T;
\r
1923 ByteNo = (uint8_t)NdefMap->TLVStruct.NdefTLVByte;
\r
1924 BlockNo = NdefMap->TLVStruct.NdefTLVBlock;
\r
1927 NdefMap->State = PH_FRINFC_TOPAZ_STATE_WR_CC_OR_TLV;
\r
1928 Result = phFriNfc_Tpz_H_WrAByte( NdefMap, BlockNo, ByteNo,TempByteVal);
\r
1932 static NFCSTATUS phFriNfc_Tpz_H_ProCCTLV(phFriNfc_NdefMap_t *NdefMap)
\r
1934 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
\r
1935 NFCSTATUS_INVALID_RECEIVE_LENGTH);
\r
1936 switch(NdefMap->TopazContainer.InternalState)
\r
1938 case PH_FRINFC_TOPAZ_WR_CC_BYTE0:
\r
1939 /* Process the CC byte */
\r
1940 /* Check the response */
\r
1941 if((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] ==
\r
1942 PH_FRINFC_TOPAZ_CC_BYTE0) &&
\r
1943 (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
\r
1945 NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_CC_BYTE1;
\r
1946 Result = phFriNfc_Tpz_H_WrCCorTLV(NdefMap);
\r
1950 case PH_FRINFC_TOPAZ_WR_CC_BYTE1:
\r
1951 /* Process the CC byte */
\r
1952 /* Check the response */
\r
1953 if((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] ==
\r
1954 PH_FRINFC_TOPAZ_CC_BYTE1) &&
\r
1955 (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
\r
1957 NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_CC_BYTE2;
\r
1958 Result = phFriNfc_Tpz_H_WrCCorTLV(NdefMap);
\r
1962 case PH_FRINFC_TOPAZ_WR_CC_BYTE2:
\r
1963 /* Process the CC byte */
\r
1964 /* Check the response */
\r
1965 if((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] ==
\r
1966 PH_FRINFC_TOPAZ_CC_BYTE2_MAX) &&
\r
1967 (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
\r
1969 NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_CC_BYTE3;
\r
1970 Result = phFriNfc_Tpz_H_WrCCorTLV(NdefMap);
\r
1974 case PH_FRINFC_TOPAZ_WR_CC_BYTE3:
\r
1975 /* Process the CC byte */
\r
1976 /* Check the response */
\r
1977 if((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] ==
\r
1978 PH_FRINFC_TOPAZ_CC_BYTE3_RW) &&
\r
1979 (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
\r
1981 NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_T_OF_TLV;
\r
1982 Result = phFriNfc_Tpz_H_WrCCorTLV(NdefMap);
\r
1986 case PH_FRINFC_TOPAZ_WR_T_OF_TLV:
\r
1988 /* Check the response */
\r
1989 if((NdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL0] ==
\r
1990 PH_FRINFC_TOPAZ_NDEF_T) &&
\r
1991 (*NdefMap->SendRecvLength == PH_FRINFC_TOPAZ_VAL1))
\r
1993 /* Increment the Byte Number */
\r
1994 NdefMap->TopazContainer.ByteNumber++;
\r
1995 /* Check the block and byte number */
\r
1996 phFriNfc_Tpz_H_BlkChk(NdefMap);
\r
1997 /* Process the T of NDEF TLV */
\r
1998 NdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE_NMN;
\r
2000 /* Here the NMN is written 0, so internal state is used */
\r
2001 NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_WR_NMN_0;
\r
2003 /*Inside this call Write NMN (block number 1 and byte number 0) = 0 */
\r
2004 Result = phFriNfc_Tpz_H_WrAByte( NdefMap, PH_FRINFC_TOPAZ_VAL1,
\r
2005 PH_FRINFC_TOPAZ_VAL0,PH_FRINFC_TOPAZ_VAL0);
\r
2013 #include <phUnitTestNfc_Topaz_static.c>
\r
2016 #endif /* PH_FRINFC_MAP_TOPAZ_DISABLED */
\r