src/phFriNfc_TopazDynamicMap.c

   1 /*
   2  * Copyright (C) 2010 NXP Semiconductors
   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 * \file  phFriNfc_TopazDynamicMap.c
  19 * \brief NFC Ndef Mapping For Remote Devices.
  20 *
  21 * Project: NFC-FRI
  22 *
  23 * $Date: Wed Oct 27 10:21:29 2010 $
  24 * $Author: ing02260 $
  25 * $Revision: 1.41 $
  26 * $Aliases:  $
  27 *
  28 */
  29
  30
  31
  32 #include <phFriNfc_NdefMap.h>
  33 #include <phFriNfc_TopazMap.h>
  34 #include <phFriNfc_MapTools.h>
  35 #include <phFriNfc_OvrHal.h>
  36
  37 #if !(defined(PH_FRINFC_MAP_TOPAZ_DISABLED ) || defined (PH_FRINFC_MAP_TOPAZ_DYNAMIC_DISABLED ))
  38
  39 /*! \ingroup grp_file_attributes
  40 *  \name NDEF Mapping
  41 *
  42 * File: \ref phFriNfcNdefMap.c
  43 *
  44 */
  45 /*@{*/
  46 #define PHFRINFCTOPAZMAP_FILEREVISION "$Revision: 1.41 $"
  47 #define PHFRINFCTOPAZMAP_FILEALIASES  "$Aliases:  $"
  48 /*@}*/
  49 /*!
  50 * \name Topaz Mapping - Helper data structures and macros
  51 *
  52 */
  53 /*@{*/
  54
  55 /********************************** Start of data structures *********************************/
  56 #ifdef FRINFC_READONLY_NDEF
  57
  58     #define DYN_CC_BLOCK_NUMBER                                     (0x01U)
  59     #define DYN_STATIC_LOCK_BLOCK_NUM                               (0x0EU)
  60
  61     #define DYN_STATIC_LOCK0_BYTE_NUM                               (0x00U)
  62     #define DYN_STATIC_LOCK0_BYTE_VALUE                             (0xFFU)
  63
  64     #define DYN_STATIC_LOCK1_BYTE_NUM                               (0x01U)
  65     #define DYN_STATIC_LOCK1_BYTE_VALUE                             (0x7FU)
  66
  67     #define DYN_CC_RWA_BYTE_NUMBER                                  (0x03U)
  68     #define DYN_CC_READ_ONLY_VALUE                                  (0x0FU)
  69
  70 #endif /* #ifdef FRINFC_READONLY_NDEF */
  71
  72 /*!
  73 * \brief \copydoc page_ovr enum for the topaz sequence of execution.
  74 */
  75 typedef enum phFriNfc_Tpz_ParseSeq
  76 {
  77     LOCK_T_TLV,
  78     LOCK_L_TLV,
  79     LOCK_V_TLV,
  80     MEM_T_TLV,
  81     MEM_L_TLV,
  82     MEM_V_TLV,
  83     NDEF_T_TLV,
  84     NDEF_L_TLV,
  85     NDEF_V_TLV
  86 }phFriNfc_Tpz_ParseSeq_t;
  87
  88 typedef enum phFriNfc_Tpz_WrSeq
  89 {
  90     WR_NDEF_T_TLV,
  91     WR_NMN_0,
  92     WR_LEN_1_0,
  93     WR_LEN_2_0,
  94     WR_LEN_3_0,
  95     WR_DATA,
  96     WR_DATA_READ_REQD,
  97     WR_LEN_1_VALUE,
  98     WR_LEN_2_VALUE,
  99     WR_LEN_3_VALUE,
 100     WR_NMN_E1
 101 }phFriNfc_Tpz_WrSeq_t;
 102
 103 #ifdef FRINFC_READONLY_NDEF
 104
 105 typedef enum phFriNfc_Tpz_RO_Seq
 106 {
 107     WR_READONLY_CC,
 108     RD_LOCK_BYTES,
 109     WR_LOCK_BYTES,
 110     RD_STATIC_LOCK_BYTE0,
 111     WR_STATIC_LOCK_BYTE0,
 112     WR_STATIC_LOCK_BYTE1
 113 }phFriNfc_Tpz_RO_Seq_t;
 114
 115 #endif /* #ifdef FRINFC_READONLY_NDEF  */
 116
 117 /********************************** End of data structures *********************************/
 118
 119 /********************************** Start of Macros *********************************/
 120 /* New state for TOPAZ dynamic  card*/
 121 #define PH_FRINFC_TOPAZ_STATE_RD_FOR_WR_NDEF            (0x10U)
 122
 123 #ifdef FRINFC_READONLY_NDEF
 124     #define PH_FRINFC_TOPAZ_STATE_READ_ONLY             (0x11U)
 125 #endif /* #ifdef FRINFC_READONLY_NDEF */
 126
 127 #define NIBBLE_SIZE                                     (0x04U)
 128 /* Byte shifting for the topaz */
 129 #define TOPAZ_BYTE_SHIFT                                (0x08U)
 130 /* Lock and memory control TLV length. Always 3 bytes */
 131 #define TOPAZ_MEM_LOCK_TLV_LENGTH                       (0x03U)
 132 /* UID byte length */
 133 #define TOPAZ_UID_BYTES_LENGTH                          (0x08U)
 134
 135 /* Number os static lock and reserved bytes */
 136 #define TOPAZ_STATIC_LOCK_RES_BYTES                     (0x18U)
 137 /* Number of static lock and reserved memory. This value is 3 (because
 138     block number D, E and F are lock and reserved blocks */
 139 #define TOPAZ_STATIC_LOCK_BLOCK_AREAS                   (0x03U)
 140 /* First lock or reserved block in the static area of the card */
 141 #define TOPAZ_STATIC_LOCK_FIRST_BLOCK_NO                (0x0DU)
 142 /* First lock or reserved byte number in the static area of the card */
 143 #define TOPAZ_STATIC_LOCK_RES_START                     (0x68U)
 144 /* End lock or reserved byte number in the static area of the card */
 145 #define TOPAZ_STATIC_LOCK_RES_END                       (0x78U)
 146
 147 /* CC byte length */
 148 #define TOPAZ_CC_BYTES_LENGTH                           (0x04U)
 149
 150 /* In TOPAZ card each block has 8 bytes */
 151 #define TOPAZ_BYTES_PER_BLOCK                           (0x08U)
 152 /* Each byte has 8 bites */
 153 #define TOPAZ_BYTE_SIZE_IN_BITS                         (0x08U)
 154
 155 /* This mask is to get the least significant NIBBLE from a BYTE */
 156 #define TOPAZ_NIBBLE_MASK                               (0x0FU)
 157 /* This is used to mask the least significant BYTE from a TWO BYTE value */
 158 #define TOPAZ_BYTE_LENGTH_MASK                          (0x00FFU)
 159
 160 /* Total segments in TOPAZ 512 bytes card. Each segment = 128 bytes,
 161 so there are 4 segements in the card */
 162 #define TOPAZ_TOTAL_SEG_TO_READ                         (0x04U)
 163 /* SPEC version value shall be 0x10 as per the TYPE 1 specification */
 164 #define TOPAZ_SPEC_VERSION                              (0x10U)
 165
 166 /* Response length for READ SEGMENT command is 128 bytes */
 167 #define TOPAZ_SEGMENT_READ_LENGTH                       (0x80U)
 168 /* Response length for WRITE-1E command is 1 byte */
 169 #define TOPAZ_WRITE_1_RESPONSE                          (0x01U)
 170 /* Response length for WRITE-8E command is 8 bytes */
 171 #define TOPAZ_WRITE_8_RESPONSE                          (0x08U)
 172 /* Response length for READ-8 command is 8 bytes */
 173 #define TOPAZ_READ_8_RESPONSE                           (0x08U)
 174
 175 /* Data bytes that can be written for the WRITE-8E command is 8 bytes */
 176 #define TOPAZ_WRITE_8_DATA_LENGTH                       (0x08U)
 177
 178 /* Get the exact byte address of the card from the segment number
 179     and the parse index of each segment */
 180 #define TOPAZ_BYTE_ADR_FROM_SEG(seg, parse_index) \
 181     (((seg) * TOPAZ_SEGMENT_READ_LENGTH) + (parse_index))
 182
 183 /* Get the segment number of the card from the byte address */
 184 #define TOPAZ_SEG_FROM_BYTE_ADR(byte_addr) \
 185     ((byte_addr) / TOPAZ_SEGMENT_READ_LENGTH)
 186 /* Get the block number of the card from the byte address */
 187 #define TOPAZ_BLK_FROM_BYTE_ADR(byte_addr) \
 188     ((byte_addr) / TOPAZ_BYTES_PER_BLOCK)
 189 /* Get the block offset of a block number of the card from the byte address */
 190 #define TOPAZ_BYTE_OFFSET_FROM_BYTE_ADR(byte_addr) \
 191     ((byte_addr) % TOPAZ_BYTES_PER_BLOCK)
 192 /* Get the exact byte address of the card from the block number
 193     and the byte offset of the block number */
 194 #define TOPAZ_BYTE_ADR_FROM_BLK(block_no, byte_offset) \
 195     (((block_no) * TOPAZ_BYTES_PER_BLOCK) + (byte_offset))
 196 /* To increment the block number and if block number overlaps with the
 197     static lock and reserved blocks, then skip the blocks */
 198 #define TOPAZ_INCREMENT_SKIP_STATIC_BLOCK(block_no) \
 199     ((((block_no) + 1) == TOPAZ_STATIC_LOCK_FIRST_BLOCK_NO) ? \
 200     (((block_no) + 1) + TOPAZ_STATIC_LOCK_BLOCK_AREAS) : \
 201     ((block_no) + 1))
 202
 203 #ifdef FRINFC_READONLY_NDEF
 204
 205 #define TOPAZ_CONVERT_BITS_TO_BYTES(bits_to_bytes) \
 206             (((bits_to_bytes % TOPAZ_BYTE_SIZE_IN_BITS) > 0) ? \
 207             ((bits_to_bytes / TOPAZ_BYTE_SIZE_IN_BITS) + 1) : \
 208             (bits_to_bytes / TOPAZ_BYTE_SIZE_IN_BITS))
 209
 210 #endif /* #ifdef FRINFC_READONLY_NDEF */
 211 /********************************** End of Macros *********************************/
 212
 213 /*@}*/
 214
 215
 216 /*!
 217 * \name Topaz Mapping - Helper Functions
 218 *
 219 */
 220 /*@{*/
 221
 222 /*!
 223 * \brief \copydoc page_ovr Helper function for Topaz. This function shall read defined
 224 * bytes from the card.
 225 */
 226 static
 227 NFCSTATUS
 228 phFriNfc_Tpz_H_NxpRead (
 229     phFriNfc_NdefMap_t          *psNdefMap);
 230
 231 /*!
 232 * \brief \copydoc page_ovr Helper function for Topaz. This function shall process
 233 * received read id command.
 234 */
 235 static
 236 NFCSTATUS
 237 phFriNfc_Tpz_H_ChkReadID (
 238     phFriNfc_NdefMap_t          *psNdefMap);
 239
 240
 241 /*!
 242 * \brief \copydoc page_ovr Helper function for Topaz. This function shall process
 243 * read response.
 244 */
 245 static
 246 NFCSTATUS
 247 phFriNfc_Tpz_H_ProReadResp (
 248     phFriNfc_NdefMap_t  *psNdefMap);
 249
 250 /*!
 251 * \brief \copydoc page_ovr Helper function for Topaz. This function calls the
 252 * completion routine
 253 */
 254 static
 255 void
 256 phFriNfc_Tpz_H_Complete (
 257     phFriNfc_NdefMap_t  *NdefMap,
 258     NFCSTATUS           Status);
 259
 260
 261 /*!
 262 * \brief \copydoc page_ovr Helper function for Topaz check ndef. This function checks
 263 * the lock bits and set a card state
 264 */
 265 static
 266 NFCSTATUS
 267 phFriNfc_Tpz_H_ChkLockBits (
 268     phFriNfc_NdefMap_t  *psNdefMap);
 269
 270 /*!
 271 * \brief \copydoc page_ovr Helper function for Topaz. This function writes defined
 272 * bytes into the card
 273 */
 274 static
 275 NFCSTATUS
 276 phFriNfc_Tpz_H_NxpWrite (
 277     phFriNfc_NdefMap_t          *psNdefMap,
 278     uint8_t                     *p_write_data,
 279     uint8_t                     wr_data_len);
 280
 281
 282 /*!
 283 * \brief \copydoc page_ovr Helper function for Topaz. This function parses the read bytes
 284 * till the NDEF TLV is found. Also, it returns error if it founds wrong TLVs.
 285 */
 286 static
 287 NFCSTATUS
 288 phFriNfc_Tpz_H_ParseTLVs (
 289     phFriNfc_NdefMap_t          *psNdefMap);
 290
 291 /*!
 292  * \brief \copydoc page_ovr Helper function for Topaz. This function parses the read bytes
 293  * till the TYPE of the LOCK control TLV is found.
 294  * Also, it returns error if it founds wrong TYPE.
 295  */
 296 static
 297 NFCSTATUS
 298 phFriNfc_Tpz_H_ParseLockTLVType (
 299     phFriNfc_NdefMap_t          *psNdefMap,
 300     uint8_t                     *p_parse_data,
 301     uint16_t                    *p_parse_index,
 302     uint16_t                    total_len_to_parse,
 303     phFriNfc_Tpz_ParseSeq_t     *seq_to_execute);
 304
 305 /*!
 306  * \brief \copydoc page_ovr Helper function for Topaz. This function parses the read bytes
 307  * till the TYPE of the MEMORY control TLV is found.
 308  * Also, it returns error if it founds wrong TYPE.
 309  */
 310 static
 311 NFCSTATUS
 312 phFriNfc_Tpz_H_ParseMemTLVType (
 313     phFriNfc_NdefMap_t          *psNdefMap,
 314     uint8_t                     *p_parse_data,
 315     uint16_t                    *p_parse_index,
 316     uint16_t                    total_len_to_parse,
 317     phFriNfc_Tpz_ParseSeq_t     *seq_to_execute);
 318
 319 /*!
 320  * \brief \copydoc page_ovr Helper function for Topaz. This function parses the read bytes
 321  * till the TYPE of the NDEF control TLV is found.
 322  * Also, it returns error if it founds wrong TYPE.
 323  */
 324 static
 325 NFCSTATUS
 326 phFriNfc_Tpz_H_ParseNdefTLVType (
 327     phFriNfc_NdefMap_t          *psNdefMap,
 328     uint8_t                     *p_parse_data,
 329     uint16_t                    *p_parse_index,
 330     uint16_t                    total_len_to_parse,
 331     phFriNfc_Tpz_ParseSeq_t     *seq_to_execute);
 332
 333 /*!
 334  * \brief \copydoc page_ovr Helper function for Topaz. This function gets the lock bytes
 335  * information.
 336  */
 337 static
 338 NFCSTATUS
 339 phFriNfc_Tpz_H_GetLockBytesInfo (
 340     phFriNfc_NdefMap_t          *psNdefMap,
 341     uint8_t                     *p_lock_info);
 342
 343 /*!
 344  * \brief \copydoc page_ovr Helper function for Topaz. This function gets the reserved bytes
 345  * information.
 346  */
 347 static
 348 NFCSTATUS
 349 phFriNfc_Tpz_H_GetMemBytesInfo (
 350     phFriNfc_NdefMap_t          *psNdefMap,
 351     uint8_t                     *p_mem_info);
 352
 353 /*!
 354  * \brief \copydoc page_ovr Helper function for Topaz. This function copies and checks the CC bytes.
 355  * This function checks for the lock bytes value and card state also.
 356  */
 357 static
 358 NFCSTATUS
 359 phFriNfc_Tpz_H_CheckCCBytes (
 360     phFriNfc_NdefMap_t          *psNdefMap);
 361
 362 /*!
 363  * \brief \copydoc page_ovr Helper function for Topaz. This function checks the CC bytes.
 364  * If .
 365  */
 366 static
 367 NFCSTATUS
 368 phFriNfc_Tpz_H_CheckCCBytesForWrite (
 369     phFriNfc_NdefMap_t          *psNdefMap);
 370
 371
 372 /*!
 373  * \brief \copydoc page_ovr Helper function for Topaz. This function copies the read bytes.
 374  * This function also checks for the lock and reserved bytes and skips the bytes before copying it
 375  * in the buffer.
 376  */
 377 static
 378 NFCSTATUS
 379 phFriNfc_Tpz_H_CopyReadData (
 380     phFriNfc_NdefMap_t          *psNdefMap);
 381
 382 /*!
 383  * \brief \copydoc page_ovr Helper function for Topaz. This function copies the stored read bytes.
 384  * This function is used only for the offset " PH_FRINFC_NDEFMAP_SEEK_CUR ".
 385  */
 386 static
 387 NFCSTATUS
 388 phFriNfc_Tpz_H_RemainingReadDataCopy (
 389     phFriNfc_NdefMap_t          *psNdefMap);
 390
 391 /*!
 392  * \brief \copydoc page_ovr Helper function for Topaz. This function gives the exact byte address
 393  * of the value field after the NDEF TYPE field
 394  */
 395 static
 396 uint16_t
 397 phFriNfc_Tpz_H_GetNDEFValueFieldAddrForRead (
 398     phFriNfc_NdefMap_t          *psNdefMap);
 399
 400 /*!
 401  * \brief \copydoc page_ovr Helper function for Topaz. This function gives the exact byte address
 402  * of the value field after the NDEF TYPE field
 403  */
 404 static
 405 uint16_t
 406 phFriNfc_Tpz_H_GetNDEFValueFieldAddrForWrite (
 407     phFriNfc_NdefMap_t          *psNdefMap,
 408     uint16_t                     size_to_write);
 409
 410 /*!
 411  * \brief \copydoc page_ovr Helper function for Topaz. This function gives the number of bytes to skip.
 412  * This function checks the input byte address and checks if any lock or reserved bytes matches with the
 413  * given address. if yes, then it will return number od bytes to skip.
 414  */
 415 static
 416 uint16_t
 417 phFriNfc_Tpz_H_GetSkipSize (
 418     phFriNfc_NdefMap_t          *psNdefMap,
 419     uint16_t                    byte_adr_card);
 420
 421 /*!
 422  * \brief \copydoc page_ovr Helper function for Topaz. This function gives the actual data that can
 423  * be read and written in the card.
 424  * This function checks for the lock and reserved bytes and subtracts the remaining size to give the
 425  * actual size.
 426  */
 427 static
 428 NFCSTATUS
 429 phFriNfc_Tpz_H_ActualCardSize (
 430     phFriNfc_NdefMap_t          *psNdefMap);
 431
 432 /*!
 433  * \brief \copydoc page_ovr Helper function for Topaz. This function processes the response for
 434  * the write data
 435  */
 436 static
 437 NFCSTATUS
 438 phFriNfc_Tpz_H_ProWrResp (
 439     phFriNfc_NdefMap_t          *psNdefMap);
 440
 441 /*!
 442  * \brief \copydoc page_ovr Helper function for Topaz. This function processes the read 8 commands,
 443  * that is required for writing the data
 444  */
 445 static
 446 NFCSTATUS
 447 phFriNfc_Tpz_H_ProRdForWrResp (
 448     phFriNfc_NdefMap_t          *psNdefMap);
 449
 450 /*!
 451  * \brief \copydoc page_ovr Helper function for Topaz. This function copies the user data to the
 452  * write buffer and writes the data to the card. If the lock or memory blocks are in between the
 453  * write data, then read the current block
 454  */
 455 static
 456 NFCSTATUS
 457 phFriNfc_Tpz_H_CopySendWrData (
 458     phFriNfc_NdefMap_t          *psNdefMap);
 459
 460 /*!
 461  * \brief \copydoc page_ovr Helper function for Topaz. This function compares the input block
 462  * number with lock bytes block number and returns the p_skip_size which is the lock bytes
 463  * size
 464  */
 465 static
 466 uint16_t
 467 phFriNfc_Tpz_H_CompareLockBlocks (
 468     phFriNfc_NdefMap_t          *psNdefMap,
 469     uint8_t                     block_no,
 470     uint16_t                    *p_skip_size);
 471
 472 /*!
 473  * \brief \copydoc page_ovr Helper function for Topaz. This function compares the input block
 474  * number with reserved bytes block number and returns the p_skip_size which is the reserved bytes
 475  * size
 476  */
 477 static
 478 uint16_t
 479 phFriNfc_Tpz_H_CompareMemBlocks (
 480     phFriNfc_NdefMap_t          *psNdefMap,
 481     uint8_t                     block_no,
 482     uint16_t                    *p_skip_size);
 483
 484 /*!
 485  * \brief \copydoc page_ovr Helper function for Topaz. This function copies the read data and update
 486  * the user bytes by skipping lock or memory control areas. Also, used while updating the value field
 487  * skips the initial bytes and to start at the proper value field byte offset of the block
 488  */
 489 static
 490 NFCSTATUS
 491 phFriNfc_Tpz_H_CopyReadDataAndWrite (
 492     phFriNfc_NdefMap_t          *psNdefMap);
 493
 494
 495 /*!
 496  * \brief \copydoc page_ovr Helper function for Topaz. This function reads the required block for writing,
 497  * as some of the bytes shall not be overwritten
 498  */
 499 static
 500 NFCSTATUS
 501 phFriNfc_Tpz_H_RdForWrite (
 502     phFriNfc_NdefMap_t          *psNdefMap);
 503
 504 /*!
 505  * \brief \copydoc page_ovr Helper function for Topaz. This function reads the length block for writing,
 506  * updates the length bytes with 0
 507  */
 508 static
 509 NFCSTATUS
 510 phFriNfc_Tpz_H_UpdateLenFieldZeroAfterRead (
 511     phFriNfc_NdefMap_t          *psNdefMap);
 512
 513 /*!
 514  * \brief \copydoc page_ovr Helper function for Topaz. This function reads the length block for writing,
 515  * updates the length bytes with exact bytes that was written in the card
 516  */
 517 static
 518 NFCSTATUS
 519 phFriNfc_Tpz_H_UpdateLenFieldValuesAfterRead (
 520     phFriNfc_NdefMap_t          *psNdefMap);
 521
 522 /*!
 523  * \brief \copydoc page_ovr Helper function for Topaz. This function writes the NDEF TYPE of the
 524  * NDEF TLV to the specific byte address. This function is called only if the previous write is
 525  * failed or there is no NDEF TLV with correct CC bytes
 526  */
 527 static
 528 NFCSTATUS
 529 phFriNfc_Tpz_H_UpdateNdefTypeField (
 530     phFriNfc_NdefMap_t          *psNdefMap);
 531
 532 #ifdef FRINFC_READONLY_NDEF
 533
 534 static
 535 NFCSTATUS
 536 phFriNfc_Tpz_H_ProcessReadOnly (
 537     phFriNfc_NdefMap_t          *psNdefMap);
 538
 539 static
 540 NFCSTATUS
 541 phFriNfc_Tpz_H_UpdateAndWriteLockBits (
 542     phFriNfc_NdefMap_t          *psNdefMap);
 543
 544
 545 #endif /* #ifdef FRINFC_READONLY_NDEF */
 546
 547
 548 /*!
 549 * \brief Check whether a particular Remote Device is NDEF compliant.
 550 *
 551 * The function checks whether the peer device is NDEF compliant.
 552 *
 553 * \param[in] NdefMap Pointer to a valid instance of the \ref phFriNfc_NdefMap_t
 554 *                    structure describing the component context.
 555 *
 556 * \retval  NFCSTATUS_PENDING   The action has been successfully triggered.
 557 * \retval  Others              An error has occurred.
 558 *
 559 */
 560 NFCSTATUS  phFriNfc_TopazDynamicMap_ChkNdef( phFriNfc_NdefMap_t     *NdefMap)
 561 {
 562     NFCSTATUS   Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
 563         NFCSTATUS_INVALID_PARAMETER);
 564     if ( NdefMap != NULL)
 565     {
 566         /* Update the previous operation */
 567         NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE;
 568         /* Update the CR index to know from which operation completion
 569         routine has to be called */
 570         NdefMap->TopazContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_CHK_NDEF;
 571         NdefMap->TopazContainer.Cur_RW_Index = PH_FRINFC_TOPAZ_VAL0;
 572         NdefMap->TopazContainer.CurrentSeg = 0;
 573         NdefMap->TopazContainer.NdefTLVByteAddress = 0;
 574         NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
 575
 576         NdefMap->TopazContainer.CurrentBlock = 0;
 577         NdefMap->TopazContainer.WriteSeq = 0;
 578         NdefMap->TopazContainer.ExpectedSeq = 0;
 579
 580         (void)memset ((void *)&(NdefMap->LockTlv), 0,
 581                         sizeof (phFriNfc_LockCntrlTLVCont_t));
 582
 583         (void)memset ((void *)&(NdefMap->MemTlv), 0,
 584                     sizeof (phFriNfc_ResMemCntrlTLVCont_t));
 585
 586         /* Set card state */
 587         NdefMap->CardType = PH_FRINFC_NDEFMAP_TOPAZ_DYNAMIC_CARD;
 588
 589         /* Change the state to Read */
 590         NdefMap->State = PH_FRINFC_TOPAZ_STATE_READ;
 591
 592         NdefMap->TopazContainer.InternalState = PH_FRINFC_TOPAZ_DYNAMIC_INIT_CHK_NDEF;
 593 #ifdef TOPAZ_RAW_SUPPORT
 594
 595         *NdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_RSEG;
 596
 597 #else
 598
 599 #ifdef PH_HAL4_ENABLE
 600         NdefMap->Cmd.JewelCmd = phHal_eJewel_ReadSeg;
 601 #else
 602         NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead;
 603 #endif
 604
 605 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
 606
 607         Result = phFriNfc_Tpz_H_NxpRead(NdefMap);
 608
 609       }
 610     return Result;
 611 }
 612
 613
 614 /*!
 615 * \brief Initiates Reading of NDEF information from the Remote Device.
 616 *
 617 * The function initiates the reading of NDEF information from a Remote Device.
 618 * It performs a reset of the state and starts the action (state machine).
 619 * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action
 620 * has been triggered.
 621 */
 622
 623 NFCSTATUS phFriNfc_TopazDynamicMap_RdNdef( phFriNfc_NdefMap_t           *NdefMap,
 624                                         uint8_t                         *PacketData,
 625                                         uint32_t                        *PacketDataLength,
 626                                         uint8_t                         Offset)
 627 {
 628     NFCSTATUS               Result =    NFCSTATUS_SUCCESS;
 629
 630     /* Copy user buffer to the context */
 631     NdefMap->ApduBuffer = PacketData;
 632     /* Copy user length to the context */
 633     NdefMap->ApduBufferSize = *PacketDataLength;
 634     /* Update the user memory size to a context variable */
 635     NdefMap->NumOfBytesRead = PacketDataLength;
 636     /* Number of bytes read from the card is zero.
 637     This variable returns the number of bytes read
 638     from the card. */
 639     *NdefMap->NumOfBytesRead = 0;
 640     /* Index to know the length read */
 641     NdefMap->ApduBuffIndex = PH_FRINFC_TOPAZ_VAL0;
 642     /* Store the offset in the context */
 643     NdefMap->Offset = Offset;
 644     /* Update the CR index to know from which operation completion
 645     routine has to be called */
 646     NdefMap->TopazContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_RD_NDEF;
 647     NdefMap->TopazContainer.SkipLockBlkFlag = 0;
 648
 649     NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;
 650     if ((PH_FRINFC_NDEFMAP_SEEK_CUR == Offset) &&
 651         (TRUE == NdefMap->TopazContainer.ReadWriteCompleteFlag))
 652     {
 653         Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
 654                             NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
 655     }
 656     else if ((PH_NDEFMAP_CARD_STATE_INITIALIZED ==
 657             NdefMap->CardState) ||
 658             (0 == NdefMap->TopazContainer.ActualNDEFMsgSize))
 659     {
 660         /* Length field of NDEF TLV is 0, so read cannot proceed */
 661         Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
 662                             NFCSTATUS_READ_FAILED);
 663     }
 664     else if ((PH_FRINFC_NDEFMAP_SEEK_BEGIN == Offset) ||
 665         (PH_FRINFC_NDEFMAP_READ_OPE != NdefMap->PrevOperation))
 666     {
 667         /* If previous operation is not read then the read shall
 668         start from BEGIN */
 669         NdefMap->Offset = PH_FRINFC_NDEFMAP_SEEK_BEGIN;
 670         /* Initialise byte number */
 671         NdefMap->TopazContainer.Cur_RW_Index = PH_FRINFC_TOPAZ_VAL0;
 672
 673         NdefMap->TopazContainer.RemainingReadSize = 0;
 674         NdefMap->TopazContainer.ReadBufferSize = 0;
 675         NdefMap->TopazContainer.ReadWriteCompleteFlag = FALSE;
 676         NdefMap->TopazContainer.CurrentBlock = 0;
 677         NdefMap->TopazContainer.WriteSeq = 0;
 678
 679         NdefMap->TopazContainer.CurrentSeg = (uint8_t)TOPAZ_SEG_FROM_BYTE_ADR (
 680                         phFriNfc_Tpz_H_GetNDEFValueFieldAddrForRead (NdefMap));
 681
 682          /* Change the state to Read ID */
 683         NdefMap->State = PH_FRINFC_TOPAZ_STATE_READID;
 684         /*Change the state to Read ID*/
 685         NdefMap->TopazContainer.ReadWriteCompleteFlag = 0;
 686 #ifdef TOPAZ_RAW_SUPPORT
 687
 688         NdefMap->SendRecvBuf[0] = PH_FRINFC_TOPAZ_CMD_READID;
 689
 690 #else
 691
 692 #ifdef PH_HAL4_ENABLE
 693         NdefMap->Cmd.JewelCmd = phHal_eJewel_RID;
 694 #else
 695         NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRid;
 696 #endif
 697
 698 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
 699         Result =  phFriNfc_Tpz_H_NxpRead(NdefMap);
 700
 701     }
 702     else
 703     {
 704          /* Change the state to Read */
 705           NdefMap->State = PH_FRINFC_TOPAZ_STATE_READ;
 706           Result = phFriNfc_Tpz_H_RemainingReadDataCopy (NdefMap);
 707     }
 708
 709
 710     return Result;
 711 }
 712
 713 #ifdef FRINFC_READONLY_NDEF
 714
 715 NFCSTATUS
 716 phFriNfc_TopazDynamicMap_ConvertToReadOnly (
 717     phFriNfc_NdefMap_t     *psNdefMap)
 718 {
 719     NFCSTATUS                   result = NFCSTATUS_SUCCESS;
 720     uint8_t                     cc_read_only_byte = 0x0FU;
 721
 722     psNdefMap->State = PH_FRINFC_TOPAZ_STATE_READ_ONLY;
 723
 724     psNdefMap->TopazContainer.read_only_seq = 0;
 725
 726
 727
 728     psNdefMap->TopazContainer.CurrentBlock = 0x01U;
 729     psNdefMap->TopazContainer.ByteNumber = 0x03U;
 730
 731 #ifdef TOPAZ_RAW_SUPPORT
 732     *psNdefMap->SendRecvBuf = (uint8_t)PH_FRINFC_TOPAZ_CMD_WRITE_1E;
 733 #else
 734     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
 735 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
 736
 737     result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, &cc_read_only_byte,
 738                                     1);
 739
 740     if (NFCSTATUS_PENDING == result)
 741     {
 742         psNdefMap->TopazContainer.read_only_seq = (uint8_t)WR_READONLY_CC;
 743     }
 744
 745
 746     return result;
 747 }
 748
 749 #endif /* #ifdef FRINFC_READONLY_NDEF */
 750
 751 /*!
 752 * \brief Initiates Writing of NDEF information to the Remote Device.
 753 *
 754 * The function initiates the writing of NDEF information to a Remote Device.
 755 * It performs a reset of the state and starts the action (state machine).
 756 * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action
 757 * has been triggered.
 758 */
 759 NFCSTATUS phFriNfc_TopazDynamicMap_WrNdef( phFriNfc_NdefMap_t     *NdefMap,
 760                                    uint8_t                 *PacketData,
 761                                    uint32_t                *PacketDataLength,
 762                                    uint8_t                 Offset)
 763 {
 764     NFCSTATUS                   Result = NFCSTATUS_SUCCESS;
 765
 766     /* Copy user buffer to the context */
 767     NdefMap->ApduBuffer = PacketData;
 768     /* Copy user length to the context */
 769     NdefMap->ApduBufferSize = *PacketDataLength;
 770     /* Index to know the length written */
 771     NdefMap->ApduBuffIndex = 0;
 772     /* Update the user memory size to a context variable */
 773     NdefMap->WrNdefPacketLength = PacketDataLength;
 774     /* Number of bytes written to the card is zero.
 775     This variable returns the number of bytes written
 776     to the card. */
 777     *NdefMap->WrNdefPacketLength = 0;
 778     /* Update the CR index to know from which operation completion
 779     routine has to be called */
 780     NdefMap->TopazContainer.CRIndex = PH_FRINFC_NDEFMAP_CR_WR_NDEF;
 781     /* Store the offset in the context */
 782     NdefMap->Offset = Offset;
 783
 784     /* Update the previous operation to write operation */
 785     NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;
 786
 787     if (PH_NDEFMAP_CARD_STATE_READ_ONLY == NdefMap->CardState)
 788     {
 789         Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
 790                             NFCSTATUS_WRITE_FAILED);
 791     }
 792     else if ((PH_FRINFC_NDEFMAP_SEEK_CUR == Offset) &&
 793         (TRUE == NdefMap->TopazContainer.ReadWriteCompleteFlag))
 794     {
 795         /* Offset = Current, but the read has reached the End of Card */
 796         Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
 797                             NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
 798     }
 799     else if (0 == NdefMap->TopazContainer.NdefTLVByteAddress)
 800     {
 801         /* No NDEF TLV found in the card, so write not possible */
 802         Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
 803                             NFCSTATUS_NO_NDEF_SUPPORT);
 804     }
 805     else if ((PH_FRINFC_NDEFMAP_SEEK_BEGIN == Offset) ||
 806         (PH_FRINFC_NDEFMAP_WRITE_OPE != NdefMap->PrevOperation))
 807     {
 808         NdefMap->Offset = PH_FRINFC_NDEFMAP_SEEK_BEGIN;
 809         /* Initialise byte number */
 810         NdefMap->TopazContainer.Cur_RW_Index = PH_FRINFC_TOPAZ_VAL0;
 811         /* State has to be changed */
 812         NdefMap->State = PH_FRINFC_TOPAZ_STATE_READ;
 813         NdefMap->TopazContainer.ReadWriteCompleteFlag = FALSE;
 814
 815         NdefMap->TopazContainer.CurrentSeg = 0;
 816         NdefMap->TopazContainer.CurrentBlock = 1;
 817         NdefMap->TopazContainer.WriteSeq = 0;
 818
 819 #ifdef TOPAZ_RAW_SUPPORT
 820
 821         *NdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ8;
 822
 823 #else
 824
 825         /* Topaz command = Jewel Nxp Read */
 826 #ifdef PH_HAL4_ENABLE
 827         NdefMap->Cmd.JewelCmd = phHal_eJewel_Read;
 828 #else
 829         NdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead;
 830 #endif
 831
 832         NdefMap->Cmd.JewelCmd = phHal_eJewel_Read8;
 833
 834 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
 835         /* Call read segment */
 836         Result = phFriNfc_Tpz_H_NxpRead (NdefMap);
 837     }
 838     else
 839     {
 840 #if 0
 841         /* This part is to handle the Current offset,
 842         Current offset is not yet validated */
 843         Result = phFriNfc_Tpz_H_NxpWrite(NdefMap);
 844 #endif /* #if 0 */
 845     }
 846
 847     return Result;
 848 }
 849
 850
 851 /*!
 852 * \brief Completion Routine, Processing function, needed to avoid long blocking.
 853 * \note The lower (Overlapped HAL) layer must register a pointer to this function as a Completion
 854 *       Routine in order to be able to notify the component that an I/O has finished and data are
 855 *       ready to be processed.
 856 *
 857 */
 858
 859 void phFriNfc_TopazDynamicMap_Process( void       *Context,
 860                                NFCSTATUS   Status)
 861 {
 862
 863     phFriNfc_NdefMap_t      *NdefMap;
 864
 865     NdefMap = (phFriNfc_NdefMap_t *)Context;
 866
 867
 868     if((NFCSTATUS_SUCCESS & PHNFCSTBLOWER) == (Status & PHNFCSTBLOWER))
 869     {
 870         switch(NdefMap->State)
 871         {
 872             case PH_FRINFC_TOPAZ_STATE_READ:
 873             {
 874                 Status = phFriNfc_Tpz_H_ProReadResp (NdefMap);
 875                 break;
 876             }
 877
 878             case PH_FRINFC_TOPAZ_STATE_WRITE:
 879             {
 880                 Status =  phFriNfc_Tpz_H_ProWrResp (NdefMap);
 881                 break;
 882             }
 883
 884             case PH_FRINFC_TOPAZ_STATE_RD_FOR_WR_NDEF:
 885             {
 886                 Status =  phFriNfc_Tpz_H_ProRdForWrResp (NdefMap);
 887                 break;
 888             }
 889
 890             case PH_FRINFC_TOPAZ_STATE_READID:
 891             {
 892                 Status = phFriNfc_Tpz_H_ChkReadID(NdefMap);
 893                 break;
 894             }
 895
 896 #ifdef FRINFC_READONLY_NDEF
 897             case PH_FRINFC_TOPAZ_STATE_READ_ONLY:
 898             {
 899                 Status = phFriNfc_Tpz_H_ProcessReadOnly (NdefMap);
 900                 break;
 901             }
 902 #endif /* #ifdef FRINFC_READONLY_NDEF */
 903
 904             default:
 905             {
 906                 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
 907                                     NFCSTATUS_INVALID_DEVICE_REQUEST);
 908                 break;
 909             }
 910         }
 911     }
 912
 913     /* Call for the Completion Routine*/
 914     if(Status != NFCSTATUS_PENDING)
 915     {
 916         phFriNfc_Tpz_H_Complete(NdefMap, Status);
 917     }
 918 }
 919
 920 #ifdef FRINFC_READONLY_NDEF
 921
 922 static
 923 NFCSTATUS
 924 phFriNfc_Tpz_H_UpdateAndWriteLockBits (
 925     phFriNfc_NdefMap_t          *psNdefMap)
 926 {
 927     NFCSTATUS                       result = NFCSTATUS_SUCCESS;
 928     phFriNfc_TopazCont_t            *ps_tpz_info = NULL;
 929     phFriNfc_LockCntrlTLVCont_t     *ps_locktlv_info = NULL;
 930     uint8_t                         remaining_lock_bits = 0;
 931     uint8_t                         byte_index = 0;
 932     uint8_t                         lock_bytes_value[TOPAZ_BYTES_PER_BLOCK] = {0};
 933     uint8_t                         lock_byte_index = 0;
 934     uint8_t                         no_of_bits_left_in_block = 0;
 935
 936     ps_tpz_info = &(psNdefMap->TopazContainer);
 937     ps_locktlv_info = &(psNdefMap->LockTlv);
 938
 939     (void)memcpy ((void *)lock_bytes_value, (void *)psNdefMap->SendRecvBuf,
 940                     TOPAZ_BYTES_PER_BLOCK);
 941
 942     if (ps_tpz_info->CurrentBlock == ps_locktlv_info->BlkNum)
 943     {
 944         /* Get the lock bits that has to locked */
 945         remaining_lock_bits = ps_locktlv_info->LockTlvBuff[1];
 946         byte_index = (uint8_t)ps_locktlv_info->ByteNum;
 947     }
 948     else
 949     {
 950         /* This condition applies only for the lock bits not ending with
 951         " ps_locktlv_info->BlkNum ".
 952         Calculate the remaining lock bits */
 953         remaining_lock_bits = (uint8_t)(ps_locktlv_info->LockTlvBuff[1] -
 954                     ps_tpz_info->lock_bytes_written);
 955     }
 956
 957     no_of_bits_left_in_block = (uint8_t)((TOPAZ_BYTES_PER_BLOCK - byte_index) *
 958                                 TOPAZ_BYTE_SIZE_IN_BITS);
 959
 960     if (no_of_bits_left_in_block >= remaining_lock_bits)
 961     {
 962         /* Entire lock bits can be written */
 963         uint8_t                 mod_value = 0;
 964
 965         mod_value = (uint8_t)(remaining_lock_bits % TOPAZ_BYTES_PER_BLOCK);
 966
 967         if (mod_value)
 968         {
 969             /* The lock bits ends in between of a byte */
 970             /* lock bits to write is greater than 8 bits */
 971             if (mod_value > TOPAZ_BYTE_SIZE_IN_BITS)
 972             {
 973                 while (lock_byte_index <
 974                     (TOPAZ_CONVERT_BITS_TO_BYTES(remaining_lock_bits) - 1))
 975                 {
 976                     /* Set 1b to all bits left in the block */
 977                     lock_bytes_value[byte_index] = 0xFF;
 978                     lock_byte_index = (uint8_t)(lock_byte_index + 1);
 979                     byte_index = (uint8_t)(byte_index + 1);
 980                 }
 981                 /* Last byte of the lock bits shall be filled partially,
 982                     Set only the remaining lock bits and dont change
 983                     the other bit value */
 984                 lock_bytes_value[byte_index] = 0;
 985                 lock_bytes_value[byte_index] = (uint8_t)
 986                         SET_BITS8 (lock_bytes_value[byte_index], 0,
 987                                     mod_value, 1);
 988             }
 989             else
 990             {
 991                 /* lock bits to write is less than 8 bits, so
 992                     there is only one byte to write.
 993                     Set only the remaining lock bits and dont change
 994                     the other bit value */
 995                 lock_bytes_value[0] = (uint8_t)
 996                         SET_BITS8 (lock_bytes_value[0], 0,
 997                                     mod_value, 1);
 998             }
 999         } /* if (mod_value) */
1000         else
1001         {
1002             /* The lock bits exactly ends at a byte
1003             MOD operation is 00, that means entire byte value shall be 0xFF, means
1004             every bit shall be to 1 */
1005
1006             while (lock_byte_index < TOPAZ_CONVERT_BITS_TO_BYTES(remaining_lock_bits))
1007             {
1008                 /* Set 1b to all bits left in the block */
1009                 lock_bytes_value[byte_index] = 0xFF;
1010                 lock_byte_index = (uint8_t)(lock_byte_index + 1);
1011                 byte_index = (uint8_t)(byte_index + 1);
1012             }
1013         } /* else of if (mod_value) */
1014         ps_tpz_info->lock_bytes_written = remaining_lock_bits;
1015     }
1016     else /* if (no_of_bits_left_in_block >= remaining_lock_bits) */
1017     {
1018         /* Partial lock bits can be written. use next read to write
1019             the remaining lock bits  */
1020         while (lock_byte_index <  (no_of_bits_left_in_block /
1021                             TOPAZ_BYTES_PER_BLOCK))
1022         {
1023             /* Set 1b to all bits left in the block */
1024             lock_bytes_value[byte_index] = 0xFF;
1025             lock_byte_index = (uint8_t)(lock_byte_index + 1);
1026             byte_index = (uint8_t)(byte_index + 1);
1027         }
1028         ps_tpz_info->lock_bytes_written = (uint8_t)(no_of_bits_left_in_block /
1029                             TOPAZ_BYTES_PER_BLOCK);
1030     } /* else of if (no_of_bits_left_in_block >= remaining_lock_bits) */
1031
1032 #ifdef TOPAZ_RAW_SUPPORT
1033     *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
1034 #else
1035     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
1036 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1037
1038     result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, lock_bytes_value,
1039                                     sizeof (lock_bytes_value));
1040     return result;
1041 }
1042
1043 static
1044 NFCSTATUS
1045 phFriNfc_Tpz_H_ProcessReadOnly (
1046     phFriNfc_NdefMap_t          *psNdefMap)
1047 {
1048     NFCSTATUS                           result = NFCSTATUS_SUCCESS;
1049     phFriNfc_Tpz_RO_Seq_t               e_readonly_seq = RD_LOCK_BYTES;
1050     phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
1051     phFriNfc_LockCntrlTLVCont_t         *ps_locktlv_info = NULL;
1052     static uint8_t                      static_lock_bytes[2] = {0};
1053
1054     ps_tpz_info = &(psNdefMap->TopazContainer);
1055     ps_locktlv_info = &(psNdefMap->LockTlv);
1056     e_readonly_seq = (phFriNfc_Tpz_RO_Seq_t)psNdefMap->TopazContainer.read_only_seq;
1057
1058     switch (e_readonly_seq)
1059     {
1060         case WR_READONLY_CC:
1061         {
1062             if (TOPAZ_WRITE_1_RESPONSE == *psNdefMap->SendRecvLength)
1063             {
1064                 psNdefMap->TopazContainer.CurrentBlock = (uint8_t)
1065                                 psNdefMap->LockTlv.BlkNum;
1066
1067                 e_readonly_seq = RD_LOCK_BYTES;
1068 #ifdef TOPAZ_RAW_SUPPORT
1069
1070                 *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ8;
1071
1072 #else
1073
1074         /* Topaz command = Jewel Nxp Read */
1075 #ifdef PH_HAL4_ENABLE
1076                 psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read;
1077 #else
1078                 psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead;
1079 #endif
1080
1081                 psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read8;
1082
1083 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1084                 /* Call read segment */
1085                 result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
1086             }
1087             else
1088             {
1089                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1090                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1091             }
1092             break;
1093         }
1094
1095         case RD_LOCK_BYTES:
1096         {
1097             if (TOPAZ_READ_8_RESPONSE == *psNdefMap->SendRecvLength)
1098             {
1099                 result = phFriNfc_Tpz_H_UpdateAndWriteLockBits (psNdefMap);
1100
1101                 if (NFCSTATUS_PENDING == result)
1102                 {
1103                     e_readonly_seq = WR_LOCK_BYTES;
1104                 }
1105             }
1106             else
1107             {
1108                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1109                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1110             }
1111             break;
1112         }
1113
1114         case WR_LOCK_BYTES:
1115         {
1116             if (TOPAZ_WRITE_8_RESPONSE == *psNdefMap->SendRecvLength)
1117             {
1118                 ps_tpz_info->CurrentBlock = (uint8_t)
1119                                         (ps_tpz_info->CurrentBlock + 1);
1120                 if (ps_locktlv_info->LockTlvBuff[1] -
1121                     ps_tpz_info->lock_bytes_written)
1122                 {
1123 #ifdef TOPAZ_RAW_SUPPORT
1124
1125                     *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ8;
1126
1127 #else
1128
1129                     /* Topaz command = Jewel Nxp Read */
1130 #ifdef PH_HAL4_ENABLE
1131                     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read;
1132 #else
1133                     psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead;
1134 #endif
1135
1136                     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read8;
1137
1138 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1139                     /* Call read segment */
1140                     result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
1141                     e_readonly_seq = RD_LOCK_BYTES;
1142                 }
1143                 else
1144                 {
1145                     ps_tpz_info->CurrentBlock = (uint8_t)
1146                                         DYN_STATIC_LOCK_BLOCK_NUM;
1147                     ps_tpz_info->ByteNumber = (uint8_t)
1148                                         DYN_STATIC_LOCK0_BYTE_NUM;
1149 #ifdef TOPAZ_RAW_SUPPORT
1150
1151                     *psNdefMap->SendRecvBuf = (uint8_t)PH_FRINFC_TOPAZ_CMD_READ8;
1152
1153 #else
1154
1155                     /* Topaz command = Jewel Nxp Read */
1156 #ifdef PH_HAL4_ENABLE
1157                     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read;
1158 #else
1159                     psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead;
1160 #endif
1161
1162                     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read8;
1163
1164 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1165                     /* Call read segment */
1166                     result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
1167                     e_readonly_seq = RD_STATIC_LOCK_BYTE0;
1168
1169                 }
1170             }
1171             else
1172             {
1173                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1174                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1175             }
1176             break;
1177         }
1178
1179         case RD_STATIC_LOCK_BYTE0:
1180         {
1181             if (TOPAZ_READ_8_RESPONSE == *psNdefMap->SendRecvLength)
1182             {
1183                 uint8_t                 lock_byte_value = 0;
1184
1185                 (void)memcpy ((void *)static_lock_bytes,
1186                             (void *)(psNdefMap->SendRecvBuf +
1187                                 ps_tpz_info->ByteNumber),
1188                             sizeof (static_lock_bytes));
1189
1190
1191                 lock_byte_value = (uint8_t)(static_lock_bytes[0] |
1192                                     DYN_STATIC_LOCK0_BYTE_VALUE);
1193
1194 #ifdef TOPAZ_RAW_SUPPORT
1195                     *psNdefMap->SendRecvBuf = (uint8_t)PH_FRINFC_TOPAZ_CMD_WRITE_1E;
1196 #else
1197                     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
1198 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1199
1200                 result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, &lock_byte_value,
1201                                                     1);
1202
1203                     if (NFCSTATUS_PENDING == result)
1204                     {
1205                     e_readonly_seq = (uint8_t)WR_STATIC_LOCK_BYTE0;
1206                     }
1207                 }
1208             else
1209             {
1210                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1211                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1212             }
1213             break;
1214         }
1215
1216         case WR_STATIC_LOCK_BYTE0:
1217         {
1218             if (TOPAZ_WRITE_1_RESPONSE == *psNdefMap->SendRecvLength)
1219             {
1220                 uint8_t                 lock_byte_value =
1221                                         (static_lock_bytes[1] |
1222                                         DYN_STATIC_LOCK1_BYTE_VALUE);
1223
1224                 ps_tpz_info->CurrentBlock = (uint8_t)
1225                                     DYN_STATIC_LOCK_BLOCK_NUM;
1226                 ps_tpz_info->ByteNumber = (uint8_t)
1227                                     DYN_STATIC_LOCK1_BYTE_NUM;
1228 #ifdef TOPAZ_RAW_SUPPORT
1229                 *psNdefMap->SendRecvBuf = (uint8_t)PH_FRINFC_TOPAZ_CMD_WRITE_1E;
1230 #else
1231                 psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
1232 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1233
1234                 result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, &lock_byte_value,
1235                                                     1);
1236
1237                 if (NFCSTATUS_PENDING == result)
1238                 {
1239                     e_readonly_seq = (uint8_t)WR_STATIC_LOCK_BYTE1;
1240                 }
1241             }
1242             else
1243             {
1244                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1245                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1246             }
1247             break;
1248         }
1249
1250         case WR_STATIC_LOCK_BYTE1:
1251         {
1252             if (TOPAZ_WRITE_1_RESPONSE == *psNdefMap->SendRecvLength)
1253             {
1254                 /* READ ONLY successful */
1255             }
1256             else
1257             {
1258                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1259                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1260             }
1261             break;
1262         }
1263
1264         default:
1265         {
1266             result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1267                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1268             break;
1269         }
1270     }
1271
1272     psNdefMap->TopazContainer.read_only_seq = (uint8_t)e_readonly_seq;
1273     return result;
1274 }
1275
1276 #endif /* #ifdef FRINFC_READONLY_NDEF */
1277
1278 static
1279 NFCSTATUS
1280 phFriNfc_Tpz_H_ProWrResp (
1281     phFriNfc_NdefMap_t          *psNdefMap)
1282 {
1283     NFCSTATUS                           result = NFCSTATUS_SUCCESS;
1284     phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
1285     phFriNfc_Tpz_WrSeq_t                write_seq;
1286     uint8_t                             write_buf[] = {0x00};
1287     uint8_t                             write_index = 0;
1288     uint16_t                            write_len = 0;
1289     uint16_t                            len_byte_addr = 0;
1290
1291     ps_tpz_info = &(psNdefMap->TopazContainer);
1292     write_seq = (phFriNfc_Tpz_WrSeq_t)(ps_tpz_info->WriteSeq);
1293     write_len = (uint16_t)((psNdefMap->ApduBufferSize < ps_tpz_info->NDEFRWSize) ?
1294                 psNdefMap->ApduBufferSize : ps_tpz_info->NDEFRWSize);
1295
1296     switch (write_seq)
1297     {
1298         case WR_NDEF_T_TLV:
1299         {
1300             /* TYPE field of the NDEF TLV write is complete */
1301             if (TOPAZ_WRITE_8_RESPONSE == *psNdefMap->SendRecvLength)
1302             {
1303                 psNdefMap->State = (uint8_t)
1304                                     PH_FRINFC_TOPAZ_STATE_WRITE;
1305
1306                 /* Now, Write 0 to the magic number byte */
1307                 ps_tpz_info->WriteSeq = (uint8_t)WR_NMN_0;
1308                 write_seq = WR_NMN_0;
1309                 ps_tpz_info->CurrentBlock = 1;
1310                 ps_tpz_info->ByteNumber = 0;
1311
1312 #ifdef TOPAZ_RAW_SUPPORT
1313                 *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_1E;
1314 #else
1315                 psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
1316 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1317                 result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, write_buf,
1318                                                 sizeof (write_buf));
1319             }
1320             else
1321             {
1322                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1323                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1324             }
1325             break;
1326         }
1327
1328         case WR_NMN_0:
1329         {
1330             /* Magic number set to 0 write is complete */
1331             if (TOPAZ_WRITE_1_RESPONSE == *psNdefMap->SendRecvLength)
1332             {
1333                 ps_tpz_info->WriteSeq = (uint8_t)(write_seq + 1);
1334                 write_seq = (phFriNfc_Tpz_WrSeq_t)(write_seq + 1);
1335                 /* Now the sequence = WR_LEN_1_0, so Length block is read,
1336                     and only length bytes are made 0, before writing data to 0
1337                 */
1338                 result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
1339             }
1340             else
1341             {
1342                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1343                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1344             }
1345             break;
1346         }
1347
1348         case WR_LEN_1_0:
1349         {
1350             /* Length field is updated with the value 0 */
1351             if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
1352             {
1353                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1354                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1355             }
1356             else if (write_len >= 0xFF)
1357             {
1358                 ps_tpz_info->ByteNumber = 0;
1359
1360                 ps_tpz_info->CurrentBlock = (uint8_t)
1361                                     TOPAZ_INCREMENT_SKIP_STATIC_BLOCK (
1362                                     ps_tpz_info->CurrentBlock);
1363
1364                 ps_tpz_info->WriteSeq = (uint8_t)(write_seq + 1);
1365                 write_seq = (phFriNfc_Tpz_WrSeq_t)(write_seq + 1);
1366                 /* Now the sequence = WR_LEN_1_1, so Length block is read,
1367                     and only length bytes are made 0, before writing data to 0
1368                 */
1369                 result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
1370             }
1371             else
1372             {
1373                 /* NDEF data length < 0xFF */
1374                 len_byte_addr = phFriNfc_Tpz_H_GetNDEFValueFieldAddrForWrite
1375                                                 (psNdefMap, write_len);
1376                 ps_tpz_info->CurrentBlock = (uint8_t)
1377                         TOPAZ_BLK_FROM_BYTE_ADR (len_byte_addr);
1378                 ps_tpz_info->ByteNumber = (uint8_t)
1379                         TOPAZ_BYTE_OFFSET_FROM_BYTE_ADR (len_byte_addr);
1380
1381
1382                 ps_tpz_info->WriteSeq = (uint8_t)WR_DATA;
1383                 write_seq = WR_DATA;
1384
1385                 if (0 != ps_tpz_info->ByteNumber)
1386                 {
1387                     /* If data starts in between the block then read
1388                         the data */
1389                     result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
1390                 }
1391                 else
1392                 {
1393                     /* Data starts at the beginning of the block, so start
1394                         writing the user data */
1395                     result = phFriNfc_Tpz_H_CopySendWrData (psNdefMap);
1396                 }
1397             }
1398             break;
1399         }
1400
1401         case WR_LEN_2_0:
1402         case WR_LEN_2_VALUE:
1403         {
1404             /* 2nd length field is updated with the value 0 or the correct
1405                 written value */
1406             if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
1407             {
1408                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1409                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1410             }
1411             else
1412             {
1413                 ps_tpz_info->ByteNumber = 0;
1414                 ps_tpz_info->CurrentBlock = (uint8_t)
1415                                     TOPAZ_INCREMENT_SKIP_STATIC_BLOCK (
1416                                     ps_tpz_info->CurrentBlock);
1417                 ps_tpz_info->WriteSeq = (uint8_t)(write_seq + 1);
1418                 write_seq = (phFriNfc_Tpz_WrSeq_t)(write_seq + 1);
1419                 /* If length byte starts in between the block then read
1420                     the length block */
1421                 result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
1422             }
1423             break;
1424         }
1425
1426         case WR_LEN_3_0:
1427         {
1428             /* 3rd length field is updated with the value 0 */
1429             if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
1430             {
1431                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1432                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1433             }
1434             else
1435             {
1436                 len_byte_addr = phFriNfc_Tpz_H_GetNDEFValueFieldAddrForWrite
1437                                                 (psNdefMap, write_len);
1438                 ps_tpz_info->CurrentBlock = (uint8_t)
1439                         TOPAZ_BLK_FROM_BYTE_ADR (len_byte_addr);
1440                 ps_tpz_info->ByteNumber = (uint8_t)
1441                         TOPAZ_BYTE_OFFSET_FROM_BYTE_ADR (len_byte_addr);
1442
1443                 ps_tpz_info->WriteSeq = (uint8_t)(write_seq + 1);
1444                 write_seq = (phFriNfc_Tpz_WrSeq_t)(write_seq + 1);
1445
1446                 if (0 != ps_tpz_info->ByteNumber)
1447                 {
1448                     /* If data starts in between the block then read
1449                         the data */
1450                     result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
1451                 }
1452                 else
1453                 {
1454                     /* Data starts at the beginning of the block, so start
1455                         writing the user data */
1456                     result = phFriNfc_Tpz_H_CopySendWrData (psNdefMap);
1457                 }
1458             }
1459             break;
1460         }
1461
1462         case WR_DATA:
1463         {
1464             /* Data is written from the input buffer */
1465             if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
1466             {
1467                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1468                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1469             }
1470             else if (write_len == psNdefMap->ApduBuffIndex)
1471             {
1472                 /* Data to be written is completely written to the card */
1473                 *psNdefMap->WrNdefPacketLength = psNdefMap->ApduBuffIndex;
1474                 ps_tpz_info->WriteSeq = (uint8_t)WR_LEN_1_VALUE;
1475                 write_seq = WR_LEN_1_VALUE;
1476                 /* To write the first length byte, it has to be read and then
1477                     the length has to be updated */
1478                 result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
1479             }
1480             else
1481             {
1482                 ps_tpz_info->ByteNumber = 0;
1483                 /* Go to the next block */
1484                 ps_tpz_info->CurrentBlock = (uint8_t)
1485                                     TOPAZ_INCREMENT_SKIP_STATIC_BLOCK (
1486                                     ps_tpz_info->CurrentBlock);
1487                 /* Copy and write the user data */
1488                 result = phFriNfc_Tpz_H_CopySendWrData (psNdefMap);
1489             }
1490             break;
1491         }
1492
1493         case WR_DATA_READ_REQD:
1494         {
1495             /* This sequence is executed, if the first read has some
1496                 lock or reserved blocks bytes and the lock or reserved
1497                 blocks are extended to the next block  */
1498             if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
1499             {
1500                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1501                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1502             }
1503             else
1504             {
1505                 ps_tpz_info->ByteNumber = 0;
1506                 /* Go to the next block */
1507                 ps_tpz_info->CurrentBlock = (uint8_t)
1508                                     TOPAZ_INCREMENT_SKIP_STATIC_BLOCK (
1509                                     ps_tpz_info->CurrentBlock);
1510                 /* Write is complete for one block, now because lock bytes are
1511                     shifted to next blocks, the next block is read and update
1512                     the written data by skipping the lock or reserved memory bytes */
1513                 result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
1514             }
1515             break;
1516         }
1517
1518         case WR_LEN_3_VALUE:
1519         {
1520             /* 3rd LENGTH field byte is updated with correct written value */
1521             if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
1522             {
1523                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1524                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1525             }
1526             else
1527             {
1528 #ifdef TOPAZ_RAW_SUPPORT
1529                 *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_1E;
1530 #else
1531                 psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
1532 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1533
1534                 psNdefMap->State = (uint8_t)PH_FRINFC_TOPAZ_STATE_WRITE;
1535
1536                 write_buf[write_index] = PH_FRINFC_TOPAZ_CC_BYTE0;
1537                 write_index = (uint8_t)(write_index + 1);
1538
1539                 ps_tpz_info->ByteNumber = 0;
1540                 ps_tpz_info->CurrentBlock = 1;
1541
1542                 ps_tpz_info->WriteSeq = (uint8_t)WR_NMN_E1;
1543                 write_seq = WR_NMN_E1;
1544
1545                 /* Length byte write is complete, so now update the magic
1546                     number byte with value 0xE1 */
1547                 result = phFriNfc_Tpz_H_NxpWrite(psNdefMap, write_buf,
1548                                                 write_index);
1549             }
1550             break;
1551         }
1552
1553         case WR_LEN_1_VALUE:
1554         {
1555             /* 1st LENGTH field byte is updated */
1556             if (TOPAZ_WRITE_8_RESPONSE != *psNdefMap->SendRecvLength)
1557             {
1558                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1559                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1560             }
1561             else if (write_len < 0xFF)
1562             {
1563                 /* Total length to write is less than 0xFF, so LENGTH field has
1564                     only one byte, then update the magic number byte with
1565                     value 0xE1 */
1566 #ifdef TOPAZ_RAW_SUPPORT
1567                 *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_1E;
1568 #else
1569                 psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
1570 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1571                 psNdefMap->State = (uint8_t)PH_FRINFC_TOPAZ_STATE_WRITE;
1572
1573                 write_buf[write_index] = PH_FRINFC_TOPAZ_CC_BYTE0;
1574                 write_index = (uint8_t)(write_index + 1);
1575
1576                 ps_tpz_info->ByteNumber = 0;
1577                 ps_tpz_info->CurrentBlock = 1;
1578
1579                 ps_tpz_info->WriteSeq = (uint8_t)WR_NMN_E1;
1580                 write_seq = WR_NMN_E1;
1581                 result = phFriNfc_Tpz_H_NxpWrite(psNdefMap, write_buf,
1582                                                 write_index);
1583             }
1584             else
1585             {
1586                 /* 2nd byte of the LENGTH field has to be updated so,
1587                     read the block, before updating it */
1588                 ps_tpz_info->ByteNumber = 0;
1589                 ps_tpz_info->CurrentBlock = (uint8_t)
1590                                     TOPAZ_INCREMENT_SKIP_STATIC_BLOCK (
1591                                     ps_tpz_info->CurrentBlock);
1592                 ps_tpz_info->WriteSeq = (uint8_t)WR_LEN_2_VALUE;
1593                 write_seq = WR_LEN_2_VALUE;
1594                 result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
1595             }
1596             break;
1597         }
1598
1599         case WR_NMN_E1:
1600         {
1601             /* Magic number is written, so update the actual ndef length.  */
1602             if (TOPAZ_WRITE_1_RESPONSE == *psNdefMap->SendRecvLength)
1603             {
1604                 *psNdefMap->WrNdefPacketLength = (uint32_t)
1605                                                 psNdefMap->ApduBuffIndex;
1606                 ps_tpz_info->ActualNDEFMsgSize = (uint16_t)
1607                                                 psNdefMap->ApduBuffIndex;
1608             }
1609             else
1610             {
1611                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1612                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
1613             }
1614             break;
1615         }
1616
1617         default:
1618         {
1619             break;
1620         }
1621     }
1622
1623     return result;
1624 }
1625
1626 static
1627 NFCSTATUS
1628 phFriNfc_Tpz_H_UpdateNdefTypeField (
1629     phFriNfc_NdefMap_t          *psNdefMap)
1630 {
1631     NFCSTATUS                           result = NFCSTATUS_SUCCESS;
1632     phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
1633     uint8_t                             write_buf[TOPAZ_WRITE_8_DATA_LENGTH];
1634
1635     ps_tpz_info = &(psNdefMap->TopazContainer);
1636
1637     (void)memcpy ((void *)write_buf, (void *)
1638                 psNdefMap->SendRecvBuf, TOPAZ_WRITE_8_DATA_LENGTH);
1639
1640     /* Update the TYPE field of the NDEF TLV */
1641     write_buf[ps_tpz_info->ByteNumber] = PH_FRINFC_TOPAZ_NDEF_T;
1642
1643     psNdefMap->State = (uint8_t)PH_FRINFC_TOPAZ_STATE_WRITE;
1644
1645 #ifdef TOPAZ_RAW_SUPPORT
1646     *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
1647 #else
1648     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
1649 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1650     result = phFriNfc_Tpz_H_NxpWrite(psNdefMap, write_buf,
1651                                     sizeof (write_buf));
1652
1653     return result;
1654 }
1655
1656 static
1657 NFCSTATUS
1658 phFriNfc_Tpz_H_ProRdForWrResp (
1659     phFriNfc_NdefMap_t          *psNdefMap)
1660 {
1661     /* This function is used during the write operation */
1662     NFCSTATUS                           result = NFCSTATUS_SUCCESS;
1663     phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
1664
1665     ps_tpz_info = &(psNdefMap->TopazContainer);
1666
1667     psNdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE;
1668
1669     if (TOPAZ_READ_8_RESPONSE == *psNdefMap->SendRecvLength)
1670     {
1671         switch ((phFriNfc_Tpz_WrSeq_t)ps_tpz_info->WriteSeq)
1672         {
1673             case WR_NDEF_T_TLV:
1674             {
1675                 /* Read bytes are for updating the TYPE field of the NDEF TLV */
1676                 result = phFriNfc_Tpz_H_UpdateNdefTypeField (psNdefMap);
1677                 break;
1678             }
1679
1680             case WR_LEN_1_0:
1681             case WR_LEN_2_0:
1682             case WR_LEN_3_0:
1683             {
1684                 /* Read bytes are for updating the LENGTH field to 0 of the NDEF TLV and
1685                 also to update the data from the user buffer */
1686                 result = phFriNfc_Tpz_H_UpdateLenFieldZeroAfterRead (psNdefMap);
1687                 break;
1688             }
1689
1690             case WR_DATA:
1691             case WR_DATA_READ_REQD:
1692             {
1693                 /* Read bytes are for skipping the lock and reserved bytes */
1694                 result = phFriNfc_Tpz_H_CopyReadDataAndWrite (psNdefMap);
1695                 break;
1696             }
1697
1698             case WR_LEN_1_VALUE:
1699             case WR_LEN_2_VALUE:
1700             case WR_LEN_3_VALUE:
1701             {
1702                 /* Read bytes are for updating the LENGTH field to the correct values
1703                     of the NDEF TLV */
1704                 result = phFriNfc_Tpz_H_UpdateLenFieldValuesAfterRead (psNdefMap);
1705                 break;
1706             }
1707
1708             default:
1709             {
1710                 /* Code must not come come here */
1711                 break;
1712             }
1713         }
1714     }
1715     else
1716     {
1717         /* Error in the length, wither the HW has sent wrong response length or
1718             the response length byte is corrupted */
1719         result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1720                             NFCSTATUS_INVALID_RECEIVE_LENGTH);
1721     }
1722
1723
1724     return result;
1725 }
1726
1727 static
1728 NFCSTATUS
1729 phFriNfc_Tpz_H_ChkReadID(
1730     phFriNfc_NdefMap_t      *psNdefMap)
1731 {
1732     NFCSTATUS   result = NFCSTATUS_SUCCESS;
1733     int         compare_result = 0;
1734     uint8_t     recv_index = 0;
1735
1736
1737     if (PH_FRINFC_TOPAZ_VAL6 == *psNdefMap->SendRecvLength)
1738     {
1739         if (((psNdefMap->SendRecvBuf[recv_index] &
1740             PH_FRINFC_TOPAZ_HEADROM0_CHK) == PH_FRINFC_TOPAZ_DYNAMIC_HEADROM0_VAL))
1741         {
1742             /* Copy UID to the context*/
1743             compare_result = phOsalNfc_MemCompare (
1744                                 psNdefMap->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid,
1745                                 &psNdefMap->SendRecvBuf[PH_FRINFC_TOPAZ_VAL2],
1746                                 TOPAZ_UID_LENGTH_FOR_READ_WRITE);
1747             if (0 == compare_result)
1748             {
1749                 /* State has to be changed */
1750                 psNdefMap->State = PH_FRINFC_TOPAZ_STATE_READ;
1751
1752                 /* Topaz command = READSEG */
1753 #ifdef TOPAZ_RAW_SUPPORT
1754
1755                 *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_RSEG;
1756
1757 #else
1758
1759 #ifdef PH_HAL4_ENABLE
1760                 psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read;
1761 #else
1762                 psNdefMap->Cmd.JewelCmd = phHal_eJewelCmdListJewelRead;
1763 #endif
1764                 psNdefMap->Cmd.JewelCmd = phHal_eJewel_ReadSeg;
1765
1766 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1767                 /* Read bytes from the card */
1768                 result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
1769             }
1770             else
1771             {
1772                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1773                                     NFCSTATUS_NO_NDEF_SUPPORT);
1774
1775             }
1776         }
1777     }
1778     else
1779     {
1780         result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1781                             NFCSTATUS_INVALID_RECEIVE_LENGTH);
1782     }
1783
1784     return result;
1785 }
1786
1787 #define TOPAZ_READ_ID_ZERO_LENGTH                   (0x06U)
1788 static
1789 NFCSTATUS
1790 phFriNfc_Tpz_H_NxpRead (
1791     phFriNfc_NdefMap_t          *psNdefMap)
1792 {
1793     NFCSTATUS           result = NFCSTATUS_SUCCESS;
1794     uint8_t             send_index = 0;
1795 #ifdef TOPAZ_RAW_SUPPORT
1796     uint8_t             read_append[] = { 0x00, 0x00, 0x00, 0x00,
1797                                         0x00, 0x00, 0x00, 0x00};
1798 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1799
1800     /* set the data for additional data exchange*/
1801     psNdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_TOPAZ_VAL0;
1802     psNdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_TOPAZ_VAL0;
1803     psNdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_TOPAZ_VAL0;
1804
1805     psNdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_TopazDynamicMap_Process;
1806     psNdefMap->MapCompletionInfo.Context = psNdefMap;
1807
1808     *psNdefMap->SendRecvLength = psNdefMap->TempReceiveLength;
1809
1810     /* Depending on the jewel command, the send length is decided */
1811 #ifdef TOPAZ_RAW_SUPPORT
1812
1813     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
1814     /* " send_index " is incremented because already received buffer is filled with
1815         TOPAZ command */
1816     send_index = (uint8_t)(send_index + 1);
1817
1818     switch (*psNdefMap->SendRecvBuf)
1819 #else
1820     switch(psNdefMap->Cmd.JewelCmd)
1821 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1822     {
1823 #ifdef TOPAZ_RAW_SUPPORT
1824
1825         case PH_FRINFC_TOPAZ_CMD_READID:
1826         {
1827             (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index),
1828                         (void *)read_append, TOPAZ_READ_ID_ZERO_LENGTH);
1829             send_index = (uint8_t)(send_index + TOPAZ_READ_ID_ZERO_LENGTH);
1830             break;
1831         }
1832
1833         case PH_FRINFC_TOPAZ_CMD_READ8:
1834         {
1835             psNdefMap->SendRecvBuf[send_index] =
1836                                     psNdefMap->TopazContainer.CurrentBlock;
1837             send_index = (uint8_t)(send_index + 1);
1838             break;
1839         }
1840
1841         case PH_FRINFC_TOPAZ_CMD_RSEG:
1842         {
1843             psNdefMap->SendRecvBuf[send_index] = (uint8_t)
1844                                             (psNdefMap->TopazContainer.CurrentSeg
1845                                              << NIBBLE_SIZE);
1846             send_index = (uint8_t)(send_index + 1);
1847             break;
1848         }
1849
1850 #else /* #ifdef TOPAZ_RAW_SUPPORT */
1851
1852 #ifdef PH_HAL4_ENABLE
1853         case phHal_eJewel_RID:
1854         case phHal_eJewel_ReadAll:
1855 #else
1856         case phHal_eJewelCmdListJewelRid:
1857         case phHal_eJewelCmdListJewelReadAll:
1858 #endif
1859         {
1860             /* For READ ID and READ ALL, send length is 0 */
1861             psNdefMap->SendLength = PH_FRINFC_TOPAZ_VAL0;
1862             break;
1863         }
1864
1865 #ifdef PH_HAL4_ENABLE
1866         case phHal_eJewel_Read:
1867 #else
1868         case phHal_eJewelCmdListJewelRead:
1869 #endif
1870         {
1871             /* Need to check the User data size request*/
1872
1873             psNdefMap->SendLength = PH_FRINFC_TOPAZ_VAL3;
1874             break;
1875         }
1876
1877         case phHal_eJewel_ReadSeg:
1878         {
1879             psNdefMap->SendRecvBuf[send_index] = (uint8_t)
1880                                             (psNdefMap->TopazContainer.CurrentSeg
1881                                              << NIBBLE_SIZE);
1882             send_index = (uint8_t)(send_index + 1);
1883             psNdefMap->SendLength = send_index;
1884             break;
1885         }
1886
1887         case phHal_eJewel_Read8:
1888         {
1889             psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read4;
1890             psNdefMap->SendRecvBuf[send_index] = psNdefMap->TopazContainer.CurrentBlock;
1891             send_index = (uint8_t)(send_index + 1);
1892             psNdefMap->SendLength = send_index;
1893             break;
1894         }
1895
1896 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1897
1898         default:
1899         {
1900             result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1901                                 NFCSTATUS_INVALID_DEVICE_REQUEST);
1902             break;
1903         }
1904     }
1905     if(result == NFCSTATUS_SUCCESS)
1906     {
1907 #ifdef TOPAZ_RAW_SUPPORT
1908
1909         if (PH_FRINFC_TOPAZ_CMD_READID != *psNdefMap->SendRecvBuf)
1910         {
1911             (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index),
1912                             (void *)read_append, sizeof (read_append));
1913             send_index = (uint8_t)(send_index + sizeof (read_append));
1914
1915             (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index),
1916                         (void *)psNdefMap->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid,
1917                         TOPAZ_UID_LENGTH_FOR_READ_WRITE);
1918             send_index = (uint8_t)(send_index +
1919                         TOPAZ_UID_LENGTH_FOR_READ_WRITE);
1920         }
1921
1922         psNdefMap->SendLength = send_index;
1923
1924 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1925         /* Call the Overlapped HAL Transceive function */
1926         result = phFriNfc_OvrHal_Transceive(    psNdefMap->LowerDevice,
1927                                                 &psNdefMap->MapCompletionInfo,
1928                                                 psNdefMap->psRemoteDevInfo,
1929                                                 psNdefMap->Cmd,
1930                                                 &psNdefMap->psDepAdditionalInfo,
1931                                                 psNdefMap->SendRecvBuf,
1932                                                 psNdefMap->SendLength,
1933                                                 psNdefMap->SendRecvBuf,
1934                                                 psNdefMap->SendRecvLength);
1935     }
1936     return result;
1937 }
1938
1939
1940 static
1941 NFCSTATUS
1942 phFriNfc_Tpz_H_NxpWrite(
1943     phFriNfc_NdefMap_t          *psNdefMap,
1944     uint8_t                     *p_write_data,
1945     uint8_t                     wr_data_len)
1946 {
1947     NFCSTATUS                   result = NFCSTATUS_SUCCESS;
1948     phFriNfc_TopazCont_t        *ps_tpz_info = NULL;
1949     uint8_t                     send_index = 0;
1950
1951     ps_tpz_info = &(psNdefMap->TopazContainer);
1952
1953     /* set the data for additional data exchange*/
1954     psNdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_TOPAZ_VAL0;
1955     psNdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_TOPAZ_VAL0;
1956     psNdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_TOPAZ_VAL0;
1957
1958     psNdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_TopazDynamicMap_Process;
1959     psNdefMap->MapCompletionInfo.Context = psNdefMap;
1960
1961     *psNdefMap->SendRecvLength = psNdefMap->TempReceiveLength;
1962
1963 #ifdef TOPAZ_RAW_SUPPORT
1964     /* " send_index " is incremented because already received buffer is filled with
1965         TOPAZ command */
1966     send_index = (uint8_t)(send_index + 1);
1967     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Raw;
1968
1969     switch (*psNdefMap->SendRecvBuf)
1970
1971 #else /* #ifdef TOPAZ_RAW_SUPPORT */
1972
1973     switch (psNdefMap->Cmd.JewelCmd)
1974
1975 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
1976     {
1977 #ifdef TOPAZ_RAW_SUPPORT
1978
1979         case PH_FRINFC_TOPAZ_CMD_WRITE_1E:
1980         {
1981             psNdefMap->SendRecvBuf[send_index] = (uint8_t)((ps_tpz_info->CurrentBlock
1982                                                 << (NIBBLE_SIZE - 1)) |
1983                                                 ps_tpz_info->ByteNumber);
1984             send_index = (uint8_t)(send_index + 1);
1985             break;
1986         }
1987
1988         case PH_FRINFC_TOPAZ_CMD_WRITE_E8:
1989         {
1990             psNdefMap->SendRecvBuf[send_index] = ps_tpz_info->CurrentBlock;
1991             send_index = (uint8_t)(send_index + 1);
1992             break;
1993         }
1994
1995 #else /* #ifdef TOPAZ_RAW_SUPPORT */
1996
1997         case phHal_eJewel_Write1E:
1998         {
1999             psNdefMap->SendRecvBuf[send_index] = (uint8_t)((ps_tpz_info->CurrentBlock
2000                                                 << (NIBBLE_SIZE - 1)) |
2001                                                 ps_tpz_info->ByteNumber);
2002             send_index = (uint8_t)(send_index + 1);
2003
2004
2005             break;
2006         }
2007
2008         case phHal_eJewel_Write8E:
2009         {
2010             psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write4E;
2011             psNdefMap->SendRecvBuf[send_index] = ps_tpz_info->CurrentBlock;
2012             send_index = (uint8_t)(send_index + 1);
2013             break;
2014         }
2015
2016 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
2017
2018         default:
2019         {
2020             result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2021                                 NFCSTATUS_INVALID_DEVICE_REQUEST);
2022             break;
2023         }
2024     }
2025
2026
2027     if (NFCSTATUS_SUCCESS == result)
2028     {
2029         (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index),
2030                     (void *)p_write_data, wr_data_len);
2031
2032         send_index = (uint8_t)(send_index + wr_data_len);
2033
2034 #ifdef TOPAZ_RAW_SUPPORT
2035
2036         (void)memcpy ((void *)(psNdefMap->SendRecvBuf + send_index),
2037                     (void *)psNdefMap->psRemoteDevInfo->RemoteDevInfo.Jewel_Info.Uid,
2038                     TOPAZ_UID_LENGTH_FOR_READ_WRITE);
2039         send_index = (uint8_t)(send_index + TOPAZ_UID_LENGTH_FOR_READ_WRITE);
2040
2041 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
2042
2043         psNdefMap->SendLength = send_index;
2044
2045         /* Call the Overlapped HAL Transceive function */
2046         result = phFriNfc_OvrHal_Transceive(    psNdefMap->LowerDevice,
2047                                                 &psNdefMap->MapCompletionInfo,
2048                                                 psNdefMap->psRemoteDevInfo,
2049                                                 psNdefMap->Cmd,
2050                                                 &psNdefMap->psDepAdditionalInfo,
2051                                                 psNdefMap->SendRecvBuf,
2052                                                 psNdefMap->SendLength,
2053                                                 psNdefMap->SendRecvBuf,
2054                                                 psNdefMap->SendRecvLength);
2055     }
2056     return result;
2057 }
2058
2059 static
2060 NFCSTATUS
2061 phFriNfc_Tpz_H_ProReadResp(
2062     phFriNfc_NdefMap_t          *psNdefMap)
2063 {
2064     NFCSTATUS                   result = NFCSTATUS_SUCCESS;
2065     phFriNfc_TopazCont_t        *ps_tpz_info = NULL;
2066     uint8_t                     write_buffer[] = {0x00};
2067
2068     ps_tpz_info = &(psNdefMap->TopazContainer);
2069
2070     switch (psNdefMap->PrevOperation)
2071     {
2072         case  PH_FRINFC_NDEFMAP_CHECK_OPE:
2073         {
2074             if (PH_FRINFC_TOPAZ_DYNAMIC_READSEG_RESP ==
2075                 *psNdefMap->SendRecvLength)
2076             {
2077                 if (0 == ps_tpz_info->CurrentSeg)
2078                 {
2079                     result = phFriNfc_Tpz_H_CheckCCBytes (psNdefMap);
2080                 }
2081
2082                 if (NFCSTATUS_SUCCESS == result)
2083                 {
2084                     result = phFriNfc_Tpz_H_ParseTLVs (psNdefMap);
2085                 }
2086             }
2087             else
2088             {
2089                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2090                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
2091             }
2092             break;
2093         }
2094
2095         case  PH_FRINFC_NDEFMAP_READ_OPE:
2096         {
2097             if (PH_FRINFC_TOPAZ_DYNAMIC_READSEG_RESP ==
2098                 *psNdefMap->SendRecvLength)
2099             {
2100                 /* call the data bytes to internal buffer*/
2101                 result = phFriNfc_Tpz_H_CopyReadData (psNdefMap);
2102             }
2103             else
2104             {
2105                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2106                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
2107             }
2108             break;
2109         }
2110
2111         case  PH_FRINFC_NDEFMAP_WRITE_OPE:
2112         {
2113             /* read the bytes for cheking the CC bytes and lock bit status*/
2114             if(TOPAZ_READ_8_RESPONSE == *psNdefMap->SendRecvLength)
2115             {
2116                 (void)memcpy ((void *)ps_tpz_info->CCByteBuf,
2117                             (void *)(psNdefMap->SendRecvBuf),
2118                             TOPAZ_CC_BYTES_LENGTH);
2119
2120                 result = phFriNfc_Tpz_H_CheckCCBytesForWrite (psNdefMap);
2121                 if (NFCSTATUS_SUCCESS == result)
2122                 {
2123                     if ((0x00 == *ps_tpz_info->CCByteBuf) ||
2124                         (NDEF_T_TLV == ps_tpz_info->ExpectedSeq))
2125                     {
2126                         /* This statement is for getting the new
2127                             NDEF TLV byte address, because 1st CC byte is
2128                             corrupted or no NDEF TLV in the card
2129
2130                             If the 1st CC byte (NDEF magic number) in the
2131                             card is 0, means that previous write has failed,
2132                             so to write the exact file
2133                             OR
2134                             The NDEF TLV is not present in the entire card, and
2135                             the sequence is NDEF_T_TLV (this means, that lock and
2136                             memory control TLV is found in the card)
2137                         */
2138                         psNdefMap->State = (uint8_t)
2139                                         PH_FRINFC_TOPAZ_STATE_RD_FOR_WR_NDEF;
2140                         ps_tpz_info->WriteSeq = (uint8_t)WR_NDEF_T_TLV;
2141
2142                         ps_tpz_info->CurrentBlock = (uint8_t)
2143                                     TOPAZ_BLK_FROM_BYTE_ADR (
2144                                         ps_tpz_info->NdefTLVByteAddress);
2145
2146                         ps_tpz_info->ByteNumber = (uint8_t)
2147                                     TOPAZ_BYTE_OFFSET_FROM_BYTE_ADR (
2148                                         ps_tpz_info->NdefTLVByteAddress);
2149
2150 #ifdef TOPAZ_RAW_SUPPORT
2151                         *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ8;
2152 #else
2153                         psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read8;
2154 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
2155
2156                         result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
2157                     }
2158                     else
2159                     {
2160                         ps_tpz_info->WriteSeq = (uint8_t)WR_NMN_0;
2161                         ps_tpz_info->CurrentBlock = 1;
2162                         ps_tpz_info->ByteNumber = 0;
2163                         psNdefMap->State = (uint8_t)
2164                                             PH_FRINFC_TOPAZ_STATE_WRITE;
2165 #ifdef TOPAZ_RAW_SUPPORT
2166                         *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_1E;
2167 #else
2168                         psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write1E;
2169 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
2170
2171                         /* Call read 8 */
2172                         result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, write_buffer,
2173                                                     sizeof (write_buffer));
2174                     }
2175
2176                 }
2177             }
2178             else
2179             {
2180                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2181                                     NFCSTATUS_INVALID_RECEIVE_LENGTH);
2182             }
2183             break;
2184         }
2185
2186         default:
2187         {
2188             result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2189                                 NFCSTATUS_INVALID_DEVICE_REQUEST);
2190             break;
2191         }
2192     }
2193
2194     return result;
2195 }
2196
2197
2198
2199 static void phFriNfc_Tpz_H_Complete(phFriNfc_NdefMap_t  *NdefMap,
2200                                     NFCSTATUS           Status)
2201 {
2202     /* set the state back to the Reset_Init state*/
2203     NdefMap->State =  PH_FRINFC_NDEFMAP_STATE_RESET_INIT;
2204
2205     /* set the completion routine*/
2206     NdefMap->CompletionRoutine[NdefMap->TopazContainer.CRIndex].
2207         CompletionRoutine(NdefMap->CompletionRoutine->Context, Status);
2208 }
2209
2210 static
2211 NFCSTATUS
2212 phFriNfc_Tpz_H_ChkLockBits(
2213     phFriNfc_NdefMap_t  *psNdefMap)
2214 {
2215     NFCSTATUS           result = NFCSTATUS_SUCCESS;
2216 #ifdef ENABLE_LOCK_BITS_CHECK
2217     uint8_t             *p_recv_buf = psNdefMap->SendRecvBuf;
2218 #endif /* #ifdef ENABLE_LOCK_BITS_CHECK */
2219     psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED;
2220
2221 #ifdef ENABLE_LOCK_BITS_CHECK
2222
2223     /* Set the card state */
2224     psNdefMap->CardState =  (uint8_t)
2225         (((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_0] ==
2226             PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_0) &&
2227             ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_1] ==
2228             PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_1)) &&
2229             ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_2] ==
2230             PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_2TO7)) &&
2231             ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_3] ==
2232             PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_2TO7)) &&
2233             ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_4] ==
2234             PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_2TO7)) &&
2235             ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_5] ==
2236             PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_2TO7)) &&
2237             ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_6] ==
2238             PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_2TO7))) &&
2239             ((p_recv_buf[PH_FRINFC_TOPAZ_DYNAMIC_LOCKBIT_BYTENO_7] ==
2240             PH_FRINFC_TOPAZ_DYNAMIC_LOCKBYTE_2TO7)) ?
2241                 PH_NDEFMAP_CARD_STATE_INITIALIZED :
2242                 PH_NDEFMAP_CARD_STATE_READ_ONLY);
2243
2244 #endif /* #ifdef ENABLE_LOCK_BITS_CHECK */
2245
2246     /* Set the card state from CC bytes */
2247     if (PH_NDEFMAP_CARD_STATE_INITIALIZED == psNdefMap->CardState)
2248     {
2249         switch ((psNdefMap->TopazContainer.CCByteBuf[3] & 0xFF))
2250         {
2251             case PH_FRINFC_TOPAZ_CC_READWRITE:
2252             {
2253                 psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED;
2254                 break;
2255             }
2256
2257             case PH_FRINFC_TOPAZ_CC_READONLY:
2258             {
2259                 psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;
2260                 break;
2261             }
2262
2263             default:
2264             {
2265                 psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
2266                 result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2267                                     NFCSTATUS_NO_NDEF_SUPPORT);
2268                 break;
2269             }
2270         }
2271     }
2272
2273     return result;
2274 }
2275
2276 static
2277 NFCSTATUS
2278 phFriNfc_Tpz_H_CheckCCBytes (
2279     phFriNfc_NdefMap_t          *psNdefMap)
2280 {
2281     NFCSTATUS                       result = NFCSTATUS_SUCCESS;
2282     phFriNfc_TopazCont_t            *ps_tpz_info = &(psNdefMap->TopazContainer);
2283     uint8_t                         *p_recv_buf = psNdefMap->SendRecvBuf;
2284     uint16_t                        parse_index = 0;
2285
2286     parse_index = (uint16_t)(parse_index + TOPAZ_UID_BYTES_LENGTH);
2287
2288     (void)memcpy ((void *)ps_tpz_info->CCByteBuf,
2289                 (void *)(p_recv_buf + parse_index),
2290                 TOPAZ_CC_BYTES_LENGTH);
2291
2292     p_recv_buf = ps_tpz_info->CCByteBuf;
2293     parse_index = 0;
2294
2295 #ifdef TOPAZ_MAGIC_NO_CHK_ENABLE
2296     /* 1st CC byte value = 0 or 0xE1 */
2297     if ((PH_FRINFC_TOPAZ_CC_BYTE0 == p_recv_buf[parse_index])
2298 #ifdef TOPAZ_MAGIC_NO_0_CHK_ENABLE
2299         || (0 == p_recv_buf[parse_index])
2300 #endif /* #if TOPAZ_MAGIC_NO_0_CHK_ENABLE */
2301         )
2302 #endif /* #ifdef TOPAZ_MAGIC_NO_CHK_ENABLE */
2303     {
2304         parse_index = (uint16_t)(parse_index + 1);
2305         /* 2nd CC byte value = 0x10 */
2306         result = phFriNfc_Tpz_H_ChkSpcVer (psNdefMap, p_recv_buf[parse_index]);
2307     }
2308 #ifdef TOPAZ_MAGIC_NO_CHK_ENABLE
2309     else
2310     {
2311         result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2312                             NFCSTATUS_NO_NDEF_SUPPORT);
2313     }
2314 #endif /* #ifdef TOPAZ_MAGIC_NO_CHK_ENABLE */
2315
2316     if (NFCSTATUS_SUCCESS == result)
2317     {
2318         parse_index = (uint16_t)(parse_index + 1);
2319         /* 3rd CC byte value = 0x3F for 512 card */
2320         if (PH_FRINFC_TOPAZ_DYNAMIC_CC_BYTE2_MMSIZE == p_recv_buf[parse_index])
2321         {
2322             /* Card size calculated as ((3rd CC byte * 8) - 4 CC bytes) */
2323             psNdefMap->CardMemSize = (uint16_t)((p_recv_buf[parse_index] *
2324                                     TOPAZ_BYTES_PER_BLOCK) -
2325                                     TOPAZ_CC_BYTES_LENGTH);
2326             ps_tpz_info->RemainingSize = (uint16_t)(psNdefMap->CardMemSize +
2327                                         TOPAZ_UID_BYTES_LENGTH +
2328                                         TOPAZ_CC_BYTES_LENGTH);
2329             result = phFriNfc_Tpz_H_ChkLockBits (psNdefMap);
2330         }
2331         else
2332         {
2333             result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2334                                 NFCSTATUS_NO_NDEF_SUPPORT);
2335         }
2336     }
2337
2338     if (NFCSTATUS_SUCCESS != result)
2339     {
2340         psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
2341     }
2342
2343     return result;
2344 }
2345
2346 static
2347 NFCSTATUS
2348 phFriNfc_Tpz_H_CheckCCBytesForWrite (
2349     phFriNfc_NdefMap_t          *psNdefMap)
2350 {
2351     NFCSTATUS                           result = NFCSTATUS_SUCCESS;
2352     phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
2353     uint8_t                             check_cc_rw[] = {TOPAZ_SPEC_VERSION,
2354                                         PH_FRINFC_TOPAZ_DYNAMIC_CC_BYTE2_MMSIZE,
2355                                         PH_FRINFC_TOPAZ_CC_READWRITE};
2356     uint8_t                             check_index = 0;
2357
2358     ps_tpz_info = &(psNdefMap->TopazContainer);
2359
2360 #ifdef TOPAZ_MAGIC_NO_CHK_ENABLE
2361     if (
2362         (PH_FRINFC_TOPAZ_CC_BYTE0 == ps_tpz_info->CCByteBuf[check_index])
2363 #if TOPAZ_MAGIC_NO_0_CHK_ENABLE
2364         || (0 == ps_tpz_info->CCByteBuf[check_index])
2365 #endif /* #if TOPAZ_MAGIC_NO_0_CHK_ENABLE */
2366         )
2367 #endif /* #ifdef TOPAZ_MAGIC_NO_CHK_ENABLE */
2368     {
2369         check_index = (uint8_t)(check_index + 1);
2370
2371         if ((check_cc_rw[0] != ps_tpz_info->CCByteBuf[1]) ||
2372             (check_cc_rw[1] != ps_tpz_info->CCByteBuf[2]) ||
2373             (check_cc_rw[2] != ps_tpz_info->CCByteBuf[3]))
2374         {
2375             result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2376                                 NFCSTATUS_NO_NDEF_SUPPORT);
2377         }
2378     }
2379 #ifdef TOPAZ_MAGIC_NO_CHK_ENABLE
2380     else
2381     {
2382         result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2383                             NFCSTATUS_NO_NDEF_SUPPORT);
2384     }
2385 #endif /* #ifdef TOPAZ_MAGIC_NO_CHK_ENABLE */
2386     return result;
2387 }
2388
2389 static
2390 uint16_t
2391 phFriNfc_Tpz_H_GetNDEFValueFieldAddrForRead (
2392     phFriNfc_NdefMap_t          *psNdefMap)
2393 {
2394     phFriNfc_TopazCont_t            *ps_tpz_info = &(psNdefMap->TopazContainer);
2395     uint16_t                        skip_size = 0;
2396     uint16_t                        byte_addr = 0;
2397     uint8_t                         exit_index = 0;
2398
2399     byte_addr = ps_tpz_info->NdefTLVByteAddress;
2400
2401     while (exit_index < ((ps_tpz_info->ActualNDEFMsgSize >= 0xFF) ? 3 : 1))
2402     {
2403         byte_addr = (uint16_t)(byte_addr + 1);
2404         if (TOPAZ_STATIC_LOCK_RES_START == byte_addr)
2405         {
2406             byte_addr = (uint16_t)(byte_addr + TOPAZ_STATIC_LOCK_RES_BYTES);
2407         }
2408         skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
2409
2410         byte_addr = (uint16_t)(byte_addr + skip_size);
2411         exit_index = (uint8_t)(exit_index + 1);
2412     }
2413
2414     byte_addr = (uint16_t)(byte_addr + 1);
2415     if (TOPAZ_STATIC_LOCK_RES_START == byte_addr)
2416     {
2417         byte_addr = (uint16_t)(byte_addr + TOPAZ_STATIC_LOCK_RES_BYTES);
2418     }
2419     skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
2420
2421     byte_addr = (uint16_t)(byte_addr + skip_size);
2422
2423     return byte_addr;
2424 }
2425
2426 static
2427 uint16_t
2428 phFriNfc_Tpz_H_GetNDEFValueFieldAddrForWrite (
2429     phFriNfc_NdefMap_t          *psNdefMap,
2430     uint16_t                    size_to_write)
2431 {
2432     phFriNfc_TopazCont_t            *ps_tpz_info = &(psNdefMap->TopazContainer);
2433     uint16_t                        skip_size = 0;
2434     uint16_t                        byte_addr = 0;
2435     uint8_t                         exit_index = 0;
2436
2437     byte_addr = ps_tpz_info->NdefTLVByteAddress;
2438
2439     while (exit_index < ((size_to_write >= 0xFF) ? 3 : 1))
2440     {
2441         byte_addr = (uint16_t)(byte_addr + 1);
2442         if (TOPAZ_STATIC_LOCK_RES_START == byte_addr)
2443         {
2444             byte_addr = (uint16_t)(byte_addr + TOPAZ_STATIC_LOCK_RES_BYTES);
2445         }
2446         skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
2447
2448         byte_addr = (uint16_t)(byte_addr + skip_size);
2449         exit_index = (uint8_t)(exit_index + 1);
2450     }
2451
2452     byte_addr = (uint16_t)(byte_addr + 1);
2453     if (TOPAZ_STATIC_LOCK_RES_START == byte_addr)
2454     {
2455         byte_addr = (uint16_t)(byte_addr + TOPAZ_STATIC_LOCK_RES_BYTES);
2456     }
2457     skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
2458
2459     byte_addr = (uint16_t)(byte_addr + skip_size);
2460
2461     return byte_addr;
2462 }
2463
2464
2465 static
2466 NFCSTATUS
2467 phFriNfc_Tpz_H_RemainingReadDataCopy (
2468     phFriNfc_NdefMap_t          *psNdefMap)
2469 {
2470     NFCSTATUS                       result = NFCSTATUS_SUCCESS;
2471     phFriNfc_TopazCont_t            *ps_tpz_info = &(psNdefMap->TopazContainer);
2472     uint8_t                         copy_temp_buf[PH_FRINFC_NDEFMAP_TOPAZ_MAX_SIZE];
2473     uint16_t                        copy_length = 0;
2474     uint16_t                        read_copy_length = 0;
2475
2476
2477     if (0 != ps_tpz_info->ReadBufferSize)
2478     {
2479         /* Data is already copied, so give it from the stored buffer */
2480         if ((psNdefMap->ApduBufferSize - psNdefMap->ApduBuffIndex) >=
2481             ps_tpz_info->ReadBufferSize)
2482         {
2483             read_copy_length = ps_tpz_info->ReadBufferSize;
2484             (void)memcpy ((void *)(psNdefMap->ApduBuffer + psNdefMap->ApduBuffIndex),
2485                     (void *)ps_tpz_info->ReadBuffer, ps_tpz_info->ReadBufferSize);
2486         }
2487         else
2488         {
2489             read_copy_length = (uint16_t)(psNdefMap->ApduBufferSize -
2490                                 psNdefMap->ApduBuffIndex);
2491
2492             copy_length = (uint16_t)(ps_tpz_info->ReadBufferSize -
2493                             read_copy_length);
2494
2495             /* Copy data to user buffer */
2496             (void)memcpy ((void *)(psNdefMap->ApduBuffer + psNdefMap->ApduBuffIndex),
2497                     (void *)ps_tpz_info->ReadBuffer, read_copy_length);
2498
2499             /* Copy data from " ReadBuffer " to temporary buffer */
2500             (void)memcpy ((void *)copy_temp_buf,
2501                     (void *)(ps_tpz_info->ReadBuffer + read_copy_length),
2502                     copy_length);
2503
2504             /* Copy data from temporary buffer to " ReadBuffer " */
2505             (void)memcpy ((void *)ps_tpz_info->ReadBuffer,
2506                     (void *)copy_temp_buf, copy_length);
2507
2508         }
2509
2510         psNdefMap->ApduBuffIndex = (uint16_t)(psNdefMap->ApduBuffIndex +
2511                                     read_copy_length);
2512         ps_tpz_info->ReadBufferSize = (uint8_t)
2513                             (ps_tpz_info->ReadBufferSize -
2514                             read_copy_length);
2515         ps_tpz_info->RemainingReadSize = (uint16_t)(
2516                             ps_tpz_info->RemainingReadSize - read_copy_length);
2517     }
2518
2519     if (0 == ps_tpz_info->RemainingReadSize)
2520     {
2521         /* No data to read, so return */
2522         *psNdefMap->NumOfBytesRead = psNdefMap->ApduBuffIndex;
2523         ps_tpz_info->ReadBufferSize = 0;
2524         ps_tpz_info->ReadWriteCompleteFlag = TRUE;
2525     }
2526     else if (psNdefMap->ApduBuffIndex == psNdefMap->ApduBufferSize)
2527     {
2528         /* User data length is read completely */
2529         *psNdefMap->NumOfBytesRead = psNdefMap->ApduBuffIndex;
2530     }
2531     else
2532     {
2533         /* Stored data is not enough, so continue reading the next segment */
2534         ps_tpz_info->CurrentSeg = (uint8_t)
2535                             (ps_tpz_info->CurrentSeg + 1);
2536 #ifdef TOPAZ_RAW_SUPPORT
2537
2538         *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_RSEG;
2539
2540 #else
2541
2542         psNdefMap->Cmd.JewelCmd = phHal_eJewel_ReadSeg;
2543
2544 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
2545         result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
2546     }
2547
2548     return result;
2549 }
2550
2551 static
2552 NFCSTATUS
2553 phFriNfc_Tpz_H_CopyReadData (
2554     phFriNfc_NdefMap_t          *psNdefMap)
2555 {
2556     NFCSTATUS                       result = NFCSTATUS_SUCCESS;
2557     phFriNfc_TopazCont_t            *ps_tpz_info = &(psNdefMap->TopazContainer);
2558     phFriNfc_LockCntrlTLVCont_t     *ps_locktlv_info = NULL;
2559     phFriNfc_ResMemCntrlTLVCont_t   *ps_memtlv_info = NULL;
2560     uint16_t                        copy_index = 0;
2561     uint16_t                        copy_length = 0;
2562     uint16_t                        recv_length = 0;
2563     static uint16_t                 skip_size = 0;
2564     /* byte address read */
2565     uint16_t                        copy_till_address = 0;
2566     uint16_t                        exact_copy_length = 0;
2567     uint16_t                        actual_ndef_length = 0;
2568
2569
2570     recv_length = *(psNdefMap->SendRecvLength);
2571
2572     actual_ndef_length = ps_tpz_info->ActualNDEFMsgSize;
2573     if (PH_FRINFC_NDEFMAP_SEEK_CUR == psNdefMap->Offset)
2574     {
2575         actual_ndef_length = (uint16_t)(
2576                             ps_tpz_info->RemainingReadSize +
2577                             psNdefMap->ApduBuffIndex);
2578     }
2579
2580     exact_copy_length = (uint16_t)((psNdefMap->ApduBufferSize >
2581                             actual_ndef_length) ? actual_ndef_length :
2582                             psNdefMap->ApduBufferSize);
2583
2584     if (0 == ps_tpz_info->CurrentSeg)
2585     {
2586         /* Skip copying the UID bytes, CC bytes, and lock and reserved memory bytes
2587              */
2588         recv_length = (*(psNdefMap->SendRecvLength) - TOPAZ_STATIC_LOCK_RES_BYTES);
2589     }
2590
2591     if (TOPAZ_SEG_FROM_BYTE_ADR (
2592         phFriNfc_Tpz_H_GetNDEFValueFieldAddrForRead (psNdefMap)) ==
2593         ps_tpz_info->CurrentSeg)
2594     {
2595         copy_index = (uint16_t)(copy_index + (
2596                     phFriNfc_Tpz_H_GetNDEFValueFieldAddrForRead (
2597                         psNdefMap) % TOPAZ_SEGMENT_READ_LENGTH));
2598         skip_size = 0;
2599     }
2600
2601     if (0 != skip_size)
2602     {
2603         copy_index = (copy_index + skip_size);
2604         skip_size = 0;
2605     }
2606
2607     while (copy_index < recv_length)
2608     {
2609         copy_length = (uint16_t)(recv_length - copy_index);
2610         copy_till_address = 0;
2611         /* IF MORE THAN ONE TLV EXISTS THEN ADD A WHILE LOOP HERE, AND PLACE THE
2612             IF STATEMENT INSIDE THE WHILE LOOP. ALSO,
2613             ps_locktlv_info = &(psNdefMap->LockTlv) change this to
2614             ps_locktlv_info = &(psNdefMap->LockTlv[index])
2615             */
2616         ps_locktlv_info = &(psNdefMap->LockTlv);
2617         if (
2618             /* Check the lock bytes belong to this segment */
2619             (ps_tpz_info->CurrentSeg ==
2620             (ps_locktlv_info->ByteAddr / TOPAZ_SEGMENT_READ_LENGTH)) &&
2621             /* Now to check if the copy_index has surpassed the lock byte address */
2622             (TOPAZ_BYTE_ADR_FROM_SEG(ps_tpz_info->CurrentSeg, copy_index)
2623             <= ps_locktlv_info->ByteAddr)
2624             )
2625         {
2626             if ((ps_locktlv_info->ByteAddr < TOPAZ_STATIC_LOCK_RES_START) ||
2627                 (ps_locktlv_info->ByteAddr >= (TOPAZ_STATIC_LOCK_RES_END + 8)))
2628             {
2629                 copy_till_address = ps_locktlv_info->ByteAddr;
2630             }
2631             skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap,
2632                                                         ps_locktlv_info->ByteAddr);
2633         }
2634
2635         /* IF MORE THAN ONE TLV EXISTS THEN ADD A WHILE LOOP HERE, AND PLACE THE
2636             IF STATEMENT INSIDE THE WHILE LOOP. ALSO,
2637             ps_memtlv_info = &(psNdefMap->MemTlv) change this to
2638             ps_memtlv_info = &(psNdefMap->MemTlv[index])
2639             */
2640         ps_memtlv_info = &(psNdefMap->MemTlv);
2641         if (
2642             /* Check the reserved bytes belong to this segment */
2643             (ps_tpz_info->CurrentSeg ==
2644             (ps_memtlv_info->ByteAddr / TOPAZ_SEGMENT_READ_LENGTH)) &&
2645             /* Now to check if the copy_index has surpassed the reserved byte address */
2646             (TOPAZ_BYTE_ADR_FROM_SEG(ps_tpz_info->CurrentSeg, copy_index)
2647             <= ps_memtlv_info->ByteAddr)
2648             )
2649         {
2650             if ((ps_memtlv_info->ByteAddr < TOPAZ_STATIC_LOCK_RES_START) ||
2651                 (ps_memtlv_info->ByteAddr >= (TOPAZ_STATIC_LOCK_RES_END + 8)))
2652             {
2653                 copy_till_address = (uint16_t)
2654                             (((ps_memtlv_info->ByteAddr < copy_till_address) ||
2655                                 (0 == copy_till_address))?
2656                             ps_memtlv_info->ByteAddr : copy_till_address);
2657             }
2658
2659             if (copy_till_address == ps_memtlv_info->ByteAddr)
2660             {
2661                 skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap,
2662                                                             ps_memtlv_info->ByteAddr);
2663             }
2664         }
2665
2666
2667         copy_length = (uint16_t) ((copy_till_address == 0) ? copy_length :
2668                     ((copy_till_address % TOPAZ_SEGMENT_READ_LENGTH) -
2669                     copy_index));
2670
2671         /* After lock bytes, there are immediate reserved bytes, so " copy_length "
2672             can be 0 */
2673         if (0 != copy_length)
2674         {
2675             /* If complete user buffer is not filled and the
2676                 read data is greater than the user data buffer, then get the
2677                 remaining size that should be copied.
2678                 The below " if " statement is used for the above scenario */
2679             if ((copy_length > (uint16_t)
2680                 (exact_copy_length - psNdefMap->ApduBuffIndex)) &&
2681                 (exact_copy_length != psNdefMap->ApduBuffIndex))
2682             {
2683                 copy_length = (uint16_t)(exact_copy_length -
2684                                         psNdefMap->ApduBuffIndex);
2685             }
2686
2687             if (exact_copy_length != psNdefMap->ApduBuffIndex)
2688             {
2689                 (void)memcpy ((void *)(psNdefMap->ApduBuffer +
2690                         psNdefMap->ApduBuffIndex),
2691                         (void *)(psNdefMap->SendRecvBuf + copy_index),
2692                         copy_length);
2693 #if 0
2694                 if (((copy_till_address == 0) ? copy_length :
2695                     ((copy_till_address % TOPAZ_SEGMENT_READ_LENGTH) -
2696                     copy_index)) > (uint16_t)
2697                     (exact_copy_length - psNdefMap->ApduBuffIndex))
2698                 {
2699                     /* Copy remaining buffer in the static memory */
2700                     (void)memcpy ((void *)(ps_tpz_info->ReadBuffer +
2701                             ps_tpz_info->ReadBufferSize),
2702                             (void *)(psNdefMap->SendRecvBuf + copy_index),
2703                             (((copy_till_address % TOPAZ_SEGMENT_READ_LENGTH) -
2704                             copy_index) - copy_length));
2705
2706                     ps_tpz_info->ReadBufferSize = (uint16_t)(((copy_till_address %
2707                                                     TOPAZ_SEGMENT_READ_LENGTH) -
2708                                                     copy_index) - copy_length);
2709
2710                     /* Copy the data in the user buffer */
2711                     copy_index = (uint16_t)(copy_index +
2712                                 ((copy_till_address % TOPAZ_SEGMENT_READ_LENGTH) -
2713                                 copy_index));
2714                 }
2715                 else
2716 #endif /* #if 0 */
2717                 {
2718                     /* Copy the data in the user buffer */
2719                     copy_index = (uint16_t)(copy_index + copy_length);
2720                 }
2721
2722                 psNdefMap->ApduBuffIndex = (uint16_t)(psNdefMap->ApduBuffIndex +
2723                                             copy_length);
2724
2725
2726             }
2727             else
2728             {
2729                 copy_length = (uint16_t) ((copy_till_address == 0) ? copy_length :
2730                             ((copy_till_address % TOPAZ_SEGMENT_READ_LENGTH) -
2731                             copy_index));
2732
2733                 /* Actual NDEF message size is greater than the last index copied in
2734                     the user buffer */
2735                 if (actual_ndef_length > (psNdefMap->ApduBuffIndex +
2736                     ps_tpz_info->ReadBufferSize))
2737                 {
2738                     /* The statement is correct, check the remaining length */
2739                     copy_length = ((copy_length > (actual_ndef_length -
2740                                 psNdefMap->ApduBuffIndex)) ?
2741                                 (actual_ndef_length -
2742                                 psNdefMap->ApduBuffIndex) :
2743                                 copy_length);
2744
2745                     /* Copy remaining buffer in the static memory */
2746                     (void)memcpy ((void *)(ps_tpz_info->ReadBuffer +
2747                                 ps_tpz_info->ReadBufferSize),
2748                                 (void *)(psNdefMap->SendRecvBuf + copy_index),
2749                                 copy_length);
2750
2751                     ps_tpz_info->ReadBufferSize = (uint8_t)(
2752                                                     ps_tpz_info->ReadBufferSize +
2753                                                     copy_length);
2754                 }
2755
2756                 /* Copy the data in the user buffer */
2757                 copy_index = (uint16_t)(copy_index + copy_length);
2758             }
2759         }
2760
2761         if (copy_index != copy_till_address)
2762         {
2763             skip_size = 0;
2764         }
2765
2766         if ((copy_index + skip_size) <= recv_length)
2767         {
2768             copy_index = (uint16_t)(copy_index + skip_size);
2769             skip_size = 0;
2770         }
2771         else
2772         {
2773             skip_size = (uint16_t)((skip_size > 0) ?
2774                                     (recv_length - copy_index) : 0);
2775             copy_index = (uint16_t)recv_length;
2776         }
2777     }
2778
2779     if (exact_copy_length != psNdefMap->ApduBuffIndex)
2780     {
2781         ps_tpz_info->CurrentSeg = (uint8_t)
2782                             (ps_tpz_info->CurrentSeg + 1);
2783 #ifdef TOPAZ_RAW_SUPPORT
2784
2785         *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_RSEG;
2786
2787 #else
2788
2789         psNdefMap->Cmd.JewelCmd = phHal_eJewel_ReadSeg;
2790
2791 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
2792         result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
2793     }
2794     else
2795     {
2796         *psNdefMap->NumOfBytesRead = psNdefMap->ApduBuffIndex;
2797         if (psNdefMap->ApduBuffIndex == actual_ndef_length)
2798         {
2799             ps_tpz_info->ReadBufferSize = 0;
2800             ps_tpz_info->ReadWriteCompleteFlag = TRUE;
2801         }
2802         else
2803         {
2804             ps_tpz_info->RemainingReadSize = (actual_ndef_length -
2805                                         psNdefMap->ApduBuffIndex);
2806         }
2807     }
2808     return result;
2809 }
2810
2811
2812 static
2813 NFCSTATUS
2814 phFriNfc_Tpz_H_ParseTLVs (
2815     phFriNfc_NdefMap_t          *psNdefMap)
2816 {
2817     NFCSTATUS                   result = NFCSTATUS_SUCCESS;
2818     phFriNfc_TopazCont_t        *ps_tpz_info = &(psNdefMap->TopazContainer);
2819     uint8_t                     *p_recv_buf = NULL;
2820     uint16_t                    recv_length = 0;
2821     uint16_t                    parse_index = 0;
2822     phFriNfc_Tpz_ParseSeq_t     expected_seq = (phFriNfc_Tpz_ParseSeq_t)
2823                                 ps_tpz_info->ExpectedSeq;
2824     uint16_t                    byte_addr = 0;
2825     /* This variable is kept static because if the size to skip LOCK or RESERVED
2826     bytes extends to next read then it shall be stored and used to skip the next
2827     read the bytes
2828     */
2829     static uint16_t             skip_size = 0;
2830     /* This variable is kept static because if the bytes extends from the read segment,
2831         then the index shall be stored
2832     This is to store index copied from the
2833     1. lock memory VALUE field bytes in the LOCK and MEMORY CONTROL TLV.
2834     2. Also, LENGTH field of the NDEF TLV */
2835     static uint8_t              lock_mem_ndef_index = 0;
2836     /* This variable is kept static because if the bytes extends from the read segment,
2837         then it has to stored
2838     This is to store the
2839     1. lock memory VALUE field bytes in the LOCK and MEMORY CONTROL TLV.
2840     2. Also, LENGTH field of the NDEF TLV */
2841     static uint8_t              lock_mem_buf[TOPAZ_MEM_LOCK_TLV_LENGTH] = {0};
2842     /* This is used in case if there is no MAGIC NUMBER found
2843                         OR
2844         TYPE field is not found after reading entire card */
2845     static uint16_t             ndef_tlv_byte_addr = 0;
2846
2847     p_recv_buf = psNdefMap->SendRecvBuf;
2848     recv_length = *psNdefMap->SendRecvLength;
2849
2850     if (0 == ps_tpz_info->CurrentSeg)
2851     {
2852         /* First read, so reset all the static variables */
2853         lock_mem_ndef_index = 0;
2854         skip_size = 0;
2855         ndef_tlv_byte_addr = 0;
2856
2857         /* Skip copying the UID bytes and CC bytes, which is first 12 bytes */
2858         parse_index = (uint16_t)(TOPAZ_UID_BYTES_LENGTH +
2859                                 TOPAZ_CC_BYTES_LENGTH);
2860         /* Delete the lock and reserved memory bytes
2861             (which are the last 24 bytes in the card) */
2862         recv_length = (uint16_t)(*(psNdefMap->SendRecvLength) -
2863                                 TOPAZ_STATIC_LOCK_RES_BYTES);
2864     }
2865
2866     while ((parse_index < recv_length) && (NFCSTATUS_SUCCESS == result) &&
2867         (NDEF_V_TLV != expected_seq))
2868     {
2869         if (0 == skip_size)
2870         {
2871             /* Macro used to get the exact byte address of the card.
2872                 This is done by using the current segment and the parse index */
2873             byte_addr = TOPAZ_BYTE_ADR_FROM_SEG (ps_tpz_info->CurrentSeg, parse_index);
2874             /* Skip size is to skip the lock or memory reserved bytes  */
2875             skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
2876         }
2877
2878         if (0 != skip_size)
2879         {
2880             if ((recv_length - parse_index) >= skip_size)
2881             {
2882                 parse_index = (uint16_t)(parse_index + skip_size);
2883                 skip_size = 0;
2884             }
2885             else
2886             {
2887                 parse_index = (uint16_t)(parse_index + (recv_length -
2888                                 parse_index));
2889                 skip_size = (uint16_t)(skip_size - (recv_length -
2890                                 parse_index));
2891             }
2892         }
2893         else
2894         {
2895             switch (expected_seq)
2896             {
2897                 case LOCK_T_TLV:
2898                 {
2899                     /* Parse the bytes till TYPE field of LOCK TLV is found, Once the
2900                         TYPE field is found then change the sequence to LOCK_L_TLV */
2901                     result = phFriNfc_Tpz_H_ParseLockTLVType (psNdefMap, p_recv_buf,
2902                                             &parse_index, recv_length, &expected_seq);
2903
2904                     break;
2905                 }
2906
2907                 case LOCK_L_TLV:
2908                 {
2909                     /* Parse the length field of LOCK TLV. Length field value of the
2910                         LOCK TLV is always 3 */
2911                     if (TOPAZ_MEM_LOCK_TLV_LENGTH != p_recv_buf[parse_index])
2912                     {
2913                         result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2914                                             NFCSTATUS_NO_NDEF_SUPPORT);
2915                     }
2916                     else
2917                     {
2918                         parse_index = (uint16_t)(parse_index + 1);
2919                         expected_seq = LOCK_V_TLV;
2920                     }
2921                     break;
2922                 }
2923
2924                 case LOCK_V_TLV:
2925                 {
2926                     /* Parse the VALUE field of the LOCK TLV */
2927                     lock_mem_buf[lock_mem_ndef_index] = p_recv_buf[parse_index];
2928                     parse_index = (uint16_t)(parse_index + 1);
2929                     lock_mem_ndef_index = (uint8_t)(lock_mem_ndef_index + 1);
2930
2931
2932                     /* All the 3 bytes are copied in the local buffer */
2933                     if (TOPAZ_MEM_LOCK_TLV_LENGTH == lock_mem_ndef_index)
2934                     {
2935 #ifdef FRINFC_READONLY_NDEF
2936                         (void)memcpy ((void *)psNdefMap->LockTlv.LockTlvBuff,
2937                                 (void *)lock_mem_buf, sizeof (lock_mem_buf));
2938 #endif /* #ifdef FRINFC_READONLY_NDEF */
2939                         /* Calculate the byte address and size of the lock bytes */
2940                         result = phFriNfc_Tpz_H_GetLockBytesInfo (psNdefMap, lock_mem_buf);
2941                         lock_mem_ndef_index = 0;
2942                         expected_seq = MEM_T_TLV;
2943                     }
2944                     break;
2945                 }
2946
2947                 case MEM_T_TLV:
2948                 {
2949                     /* Parse the bytes till TYPE field of MEMORY TLV is found, Once the
2950                         TYPE field is found then change the sequence to MEM_L_TLV */
2951                     result = phFriNfc_Tpz_H_ParseMemTLVType (psNdefMap, p_recv_buf,
2952                                             &parse_index, recv_length, &expected_seq);
2953                     break;
2954                 }
2955
2956                 case MEM_L_TLV:
2957                 {
2958                     /* Parse the length field of MEMORY TLV. Length field value of the
2959                         MEMORY TLV is always 3 */
2960                     if (TOPAZ_MEM_LOCK_TLV_LENGTH != p_recv_buf[parse_index])
2961                     {
2962                         result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2963                                             NFCSTATUS_NO_NDEF_SUPPORT);
2964                     }
2965                     else
2966                     {
2967                         parse_index = (uint16_t)(parse_index + 1);
2968                         expected_seq = MEM_V_TLV;
2969                     }
2970
2971                     break;
2972                 }
2973
2974                 case MEM_V_TLV:
2975                 {
2976                     /* Parse the VALUE field of the MEMORY TLV */
2977                     lock_mem_buf[lock_mem_ndef_index] = p_recv_buf[parse_index];
2978                     parse_index = (uint16_t)(parse_index + 1);
2979                     lock_mem_ndef_index = (uint8_t)(lock_mem_ndef_index + 1);
2980
2981                     /* All the 3 bytes are copied in the local buffer */
2982                     if (TOPAZ_MEM_LOCK_TLV_LENGTH == lock_mem_ndef_index)
2983                     {
2984                         /* Calculate the byte address and size of the lock bytes */
2985                         ndef_tlv_byte_addr = TOPAZ_BYTE_ADR_FROM_SEG (
2986                                             ps_tpz_info->CurrentSeg , parse_index);
2987                         result = phFriNfc_Tpz_H_GetMemBytesInfo (psNdefMap, lock_mem_buf);
2988                         lock_mem_ndef_index = 0;
2989                         expected_seq = NDEF_T_TLV;
2990                     }
2991
2992                     break;
2993                 }
2994
2995                 case NDEF_T_TLV:
2996                 {
2997                     /* Parse the bytes till TYPE field of NDEF TLV is found, Once the
2998                         TYPE field is found then change the sequence to NDEF_L_TLV */
2999                     result = phFriNfc_Tpz_H_ParseNdefTLVType (psNdefMap, p_recv_buf,
3000                                             &parse_index, recv_length, &expected_seq);
3001
3002                     break;
3003                 }
3004
3005                 case NDEF_L_TLV:
3006                 {
3007                     /* Length field of the NDEF TLV */
3008                     if (0 == lock_mem_ndef_index)
3009                     {
3010                         /* This is the 1st time, the loop has entered this case,
3011                             means that the NDEF byte address has to be updated */
3012                         ps_tpz_info->NdefTLVByteAddress = (uint16_t)
3013                                 TOPAZ_BYTE_ADR_FROM_SEG (ps_tpz_info->CurrentSeg,
3014                                 (parse_index - 1));
3015                     }
3016
3017                     if (0 != lock_mem_ndef_index)
3018                     {
3019                         /* There is already index has been updated, update remaining
3020                             buffer */
3021                         lock_mem_buf[lock_mem_ndef_index] = p_recv_buf[parse_index];
3022                         parse_index = (uint16_t)(parse_index + 1);
3023                         lock_mem_ndef_index = (uint8_t)(lock_mem_ndef_index + 1);
3024
3025                         if (TOPAZ_MEM_LOCK_TLV_LENGTH == lock_mem_ndef_index)
3026                         {
3027                             lock_mem_ndef_index = 0;
3028                             ps_tpz_info->ActualNDEFMsgSize = (uint16_t)((lock_mem_buf[1] <<
3029                                         TOPAZ_BYTE_SHIFT) | lock_mem_buf[2]);
3030                             expected_seq = NDEF_V_TLV;
3031                         }
3032                     }
3033                     /* Check for remaining size in the card and the actual ndef length */
3034                     else if (p_recv_buf[parse_index] <=
3035                             (ps_tpz_info->RemainingSize - (parse_index + 1)))
3036                     {
3037                         /* This check is added to see that length field in the TLV is
3038                             greater than the 1 byte */
3039                         if (0xFF == p_recv_buf[parse_index])
3040                         {
3041                             lock_mem_buf[lock_mem_ndef_index] =
3042                                                     p_recv_buf[parse_index];
3043                             lock_mem_ndef_index = (uint8_t)(lock_mem_ndef_index + 1);
3044                         }
3045                         else
3046                         {
3047                             /* Length field of the TLV is ONE byte, so update the
3048                             actual ndef size */
3049                             lock_mem_ndef_index = 0;
3050                             ps_tpz_info->ActualNDEFMsgSize = (uint16_t)
3051                                                         p_recv_buf[parse_index];
3052
3053                             expected_seq = NDEF_V_TLV;
3054                         }
3055                         parse_index = (uint16_t)(parse_index + 1);
3056                     }
3057                     else
3058                     {
3059                         /* Wrong length, remaining size in the card is lesser than the actual
3060                             ndef message length */
3061                         lock_mem_ndef_index = 0;
3062                         result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
3063                                             NFCSTATUS_NO_NDEF_SUPPORT);
3064                     }
3065                     break;
3066                 }
3067
3068                 default:
3069                 {
3070                     break;
3071                 }
3072             }/* end of switch (expected_seq) */
3073         } /* end of if (0 != skip_size) */
3074     } /* while ((parse_index < recv_length) && (NFCSTATUS_SUCCESS != result) &&
3075         (NDEF_V_TLV != expected_seq)) */
3076
3077     ps_tpz_info->ExpectedSeq = (uint8_t)expected_seq;
3078
3079     if (0 == ps_tpz_info->CurrentSeg)
3080     {
3081         /* First segment has the STATIC lock and reserved bytes, so delete it from
3082             the remaining size */
3083         ps_tpz_info->RemainingSize = (uint16_t)(ps_tpz_info->RemainingSize -
3084                                     (parse_index + TOPAZ_STATIC_LOCK_RES_BYTES));
3085
3086     }
3087     else
3088     {
3089         ps_tpz_info->RemainingSize = (uint16_t)(ps_tpz_info->RemainingSize -
3090                                     parse_index);
3091     }
3092
3093     if ((NDEF_V_TLV == expected_seq) && (NFCSTATUS_SUCCESS == result))
3094     {
3095         /* NDEF TLV found */
3096         result = phFriNfc_Tpz_H_ActualCardSize (psNdefMap);
3097
3098         if ((PH_NDEFMAP_CARD_STATE_READ_ONLY != psNdefMap->CardState) &&
3099             (0 != ps_tpz_info->ActualNDEFMsgSize))
3100         {
3101             /* Check if the card state is READ ONLY or the actual NDEF size is 0
3102                 if actual NDEF size is 0, then card state is INITIALISED
3103             */
3104             psNdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_WRITE;
3105         }
3106     }
3107
3108     if ((NFCSTATUS_SUCCESS == result) && (NDEF_V_TLV != expected_seq))
3109     {
3110         ps_tpz_info->CurrentSeg = (uint8_t)(ps_tpz_info->CurrentSeg + 1);
3111         if (TOPAZ_TOTAL_SEG_TO_READ == ps_tpz_info->CurrentSeg)
3112         {
3113             /* Max segment to read reached, so no more read can be done */
3114             result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
3115                                 NFCSTATUS_NO_NDEF_SUPPORT);
3116         }
3117         else
3118         {
3119 #ifdef TOPAZ_RAW_SUPPORT
3120
3121             *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_RSEG;
3122
3123 #else
3124
3125             psNdefMap->Cmd.JewelCmd = phHal_eJewel_ReadSeg;
3126
3127 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
3128             result = phFriNfc_Tpz_H_NxpRead(psNdefMap);
3129         }
3130     }
3131
3132     if ((NFCSTATUS_SUCCESS != result) && (NFCSTATUS_PENDING != result))
3133     {
3134         /* Error scenario */
3135         ps_tpz_info->NdefTLVByteAddress = 0;
3136         ps_tpz_info->ActualNDEFMsgSize = 0;
3137     }
3138
3139     if (NFCSTATUS_PENDING != result)
3140     {
3141         /* Exit scenario */
3142         if ((0x00 == *ps_tpz_info->CCByteBuf) ||
3143             ((NDEF_T_TLV == expected_seq) &&
3144             (TOPAZ_TOTAL_SEG_TO_READ == ps_tpz_info->CurrentSeg)))
3145         {
3146             /* This statement is for getting the new
3147                 NDEF TLV byte address, because 1st CC byte is corrupted or
3148                 no NDEF TLV in the card
3149
3150                 If the 1st CC byte (NDEF magic number) in the card is 0, means
3151                 that previous write has failed, so to write the exact TLV,
3152                 calculate the byte number
3153                                             OR
3154                 The NDEF TLV is not present in the entire card, and the sequence is
3155                 NDEF_T_TLV (this means, that lock and memory control TLV is found
3156                 in the card)
3157                 */
3158             uint16_t             size_to_skip = 0;
3159             ps_tpz_info->ActualNDEFMsgSize = 0;
3160
3161             if (0 != ndef_tlv_byte_addr)
3162             {
3163                 /* ndef_tlv_byte_addr is updated, only after complete parsing the
3164                     memory control TLV so the value shall not be 0 */
3165                 do
3166                 {
3167                     /* This loop is added to make sure the lock and reserved bytes are not
3168                     overwritten */
3169                     size_to_skip = 0;
3170                     size_to_skip = phFriNfc_Tpz_H_GetSkipSize (psNdefMap,
3171                                                             ndef_tlv_byte_addr);
3172
3173                     ndef_tlv_byte_addr = (uint16_t)(ndef_tlv_byte_addr +
3174                                             size_to_skip);
3175                 }while (0 != size_to_skip);
3176
3177                 /* Update the TLV byte address */
3178                 ps_tpz_info->NdefTLVByteAddress = ndef_tlv_byte_addr;
3179
3180                 /* Update the remaining size */
3181                 ps_tpz_info->RemainingSize = (uint16_t)(psNdefMap->CardMemSize +
3182                                         TOPAZ_UID_BYTES_LENGTH +
3183                                         TOPAZ_CC_BYTES_LENGTH);
3184
3185                 ps_tpz_info->RemainingSize = (uint16_t)
3186                                             (ps_tpz_info->RemainingSize -
3187                                             (ndef_tlv_byte_addr +
3188                                             TOPAZ_STATIC_LOCK_RES_BYTES));
3189                 (void)phFriNfc_Tpz_H_ActualCardSize (psNdefMap);
3190
3191                 /* Length byte is subtracted here to get the actual NDEF
3192                     read and write size */
3193                 ps_tpz_info->NDEFRWSize = (uint16_t)
3194                                         (ps_tpz_info->NDEFRWSize - 2);
3195                 ndef_tlv_byte_addr = 0;
3196                 result = NFCSTATUS_SUCCESS;
3197             }
3198         }
3199     }
3200
3201     return result;
3202 }
3203
3204 static
3205 NFCSTATUS
3206 phFriNfc_Tpz_H_CopyReadDataAndWrite (
3207     phFriNfc_NdefMap_t          *psNdefMap)
3208 {
3209     NFCSTATUS                           result = NFCSTATUS_SUCCESS;
3210     phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
3211     uint8_t                             write_buf[TOPAZ_WRITE_8_DATA_LENGTH];
3212     uint16_t                            write_index = 0;
3213     uint16_t                            write_len = 0;
3214     uint16_t                            byte_addr = 0;
3215     static uint16_t                     skip_size = 0;
3216
3217     ps_tpz_info = &(psNdefMap->TopazContainer);
3218
3219     write_len = (uint16_t)((psNdefMap->ApduBufferSize < ps_tpz_info->NDEFRWSize) ?
3220                         psNdefMap->ApduBufferSize : ps_tpz_info->NDEFRWSize);
3221
3222     (void)memcpy ((void *)write_buf, (void *)psNdefMap->SendRecvBuf,
3223                     TOPAZ_WRITE_8_DATA_LENGTH);
3224
3225     if (ps_tpz_info->CurrentBlock == TOPAZ_BLK_FROM_BYTE_ADR (
3226         phFriNfc_Tpz_H_GetNDEFValueFieldAddrForWrite (psNdefMap, write_len)))
3227     {
3228         skip_size = 0;
3229     }
3230
3231     /* Byte Number != 0 menas that the VALUE field of the TLV is in between the
3232         block, so the first few bytes shall be copied and then user data has to
3233         be copied
3234         */
3235     if (0 != ps_tpz_info->ByteNumber)
3236     {
3237         write_index = (uint16_t)(write_index + ps_tpz_info->ByteNumber);
3238     }
3239
3240
3241     if (0 != skip_size)
3242     {
3243         write_index = (uint16_t)(write_index + skip_size);
3244     }
3245
3246     while ((write_index < TOPAZ_WRITE_8_DATA_LENGTH) &&
3247         (write_len != psNdefMap->ApduBuffIndex))
3248     {
3249         skip_size = 0;
3250         byte_addr = TOPAZ_BYTE_ADR_FROM_BLK (ps_tpz_info->CurrentBlock,
3251                                             ps_tpz_info->ByteNumber);
3252         skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
3253
3254         if (0 == skip_size)
3255         {
3256             write_buf[write_index] =
3257                         psNdefMap->ApduBuffer[psNdefMap->ApduBuffIndex];
3258
3259             write_index = (uint16_t)(write_index + 1);
3260             psNdefMap->ApduBuffIndex = (uint16_t)
3261                                         (psNdefMap->ApduBuffIndex + 1);
3262             ps_tpz_info->ByteNumber = (uint8_t)
3263                                         (ps_tpz_info->ByteNumber + 1);
3264         }
3265         else
3266         {
3267
3268             if (skip_size >= (TOPAZ_WRITE_8_DATA_LENGTH - write_index))
3269             {
3270                 skip_size = (uint16_t)(skip_size - (TOPAZ_WRITE_8_DATA_LENGTH
3271                             - write_index));
3272                 write_index = (uint16_t)TOPAZ_WRITE_8_DATA_LENGTH;
3273             }
3274             else
3275             {
3276                 ps_tpz_info->ByteNumber = (uint8_t)
3277                             (ps_tpz_info->ByteNumber + skip_size);
3278                 write_index = (uint16_t)(write_index + skip_size);
3279                 skip_size = 0;
3280             }
3281         }
3282     }
3283
3284     if (psNdefMap->ApduBuffIndex == write_len)
3285     {
3286         ps_tpz_info->WriteSeq = (uint8_t)WR_DATA;
3287     }
3288     else
3289     {
3290         if (0 != skip_size)
3291         {
3292             ps_tpz_info->WriteSeq = (uint8_t)WR_DATA_READ_REQD;
3293
3294         }
3295         else
3296         {
3297             ps_tpz_info->WriteSeq = (uint8_t)WR_DATA;
3298         }
3299     }
3300
3301 #ifdef TOPAZ_RAW_SUPPORT
3302     *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
3303 #else
3304     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
3305 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
3306     result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, write_buf,
3307                                             sizeof (write_buf));
3308
3309     return result;
3310
3311 }
3312
3313 static
3314 NFCSTATUS
3315 phFriNfc_Tpz_H_UpdateLenFieldValuesAfterRead (
3316     phFriNfc_NdefMap_t          *psNdefMap)
3317 {
3318     /* This function is called, only when the LENGTH field has to be updated
3319         with the correct value */
3320     NFCSTATUS                           result = NFCSTATUS_SUCCESS;
3321     phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
3322     uint16_t                            write_len = 0;
3323     uint16_t                            write_index = 0;
3324     uint16_t                            byte_addr = 0;
3325     phFriNfc_Tpz_WrSeq_t                write_seq;
3326     /* This variable is kept static because if the size to skip LOCK or RESERVED
3327     bytes extends to next read then it shall be stored and used to skip the next
3328     read the bytes
3329     */
3330     static uint16_t                     skip_size = 0;
3331     uint8_t                             write_buf[TOPAZ_WRITE_8_DATA_LENGTH];
3332     uint8_t                             exit_while = FALSE;
3333
3334     ps_tpz_info = &(psNdefMap->TopazContainer);
3335     write_len = (uint16_t)((psNdefMap->ApduBufferSize < ps_tpz_info->NDEFRWSize) ?
3336                 psNdefMap->ApduBufferSize : ps_tpz_info->NDEFRWSize);
3337
3338     psNdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE;
3339
3340     (void)memcpy ((void *)write_buf, (void *)psNdefMap->SendRecvBuf,
3341                     TOPAZ_WRITE_8_DATA_LENGTH);
3342
3343     write_seq = (phFriNfc_Tpz_WrSeq_t)ps_tpz_info->WriteSeq;
3344
3345     if (WR_LEN_1_VALUE == write_seq)
3346     {
3347         /* First LENGTH field is geting updated, so the skip size
3348             reset is done */
3349         skip_size = 0;
3350     }
3351
3352     if (0 != ps_tpz_info->ByteNumber)
3353     {
3354         /* Byte Number is not 0, means that some data shall not be overwriteen till
3355             that position in the block */
3356         write_index = (uint16_t)(write_index + ps_tpz_info->ByteNumber);
3357     }
3358
3359     if (0 != skip_size)
3360     {
3361         /* This is possible after updating the FIRST length field
3362             skip size is skipped because of the pending LOCK or
3363             RESERVED bytes
3364         */
3365         write_index = (uint16_t)(write_index + skip_size);
3366     }
3367
3368     while ((write_index < TOPAZ_WRITE_8_DATA_LENGTH) &&
3369         (FALSE == exit_while))
3370     {
3371         skip_size = 0;
3372         /* Get the exact byte address from the block number and
3373             byte number */
3374         byte_addr = TOPAZ_BYTE_ADR_FROM_BLK (ps_tpz_info->CurrentBlock,
3375                                             ps_tpz_info->ByteNumber);
3376         /* Get the skip size */
3377         skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
3378
3379         if (0 == skip_size)
3380         {
3381             switch (write_seq)
3382             {
3383                 case WR_LEN_1_VALUE:
3384                 {
3385                     /* First sequenc is always to update 1st LENGTH field of the TLV */
3386                     if (write_len < 0xFF)
3387                     {
3388                         /* This means the LENGTH field is only one BYTE */
3389                         write_buf[write_index] = (uint8_t)
3390                                         psNdefMap->ApduBuffIndex;
3391                         /* Exit the loop */
3392                         exit_while = TRUE;
3393                     }
3394                     else
3395                     {
3396                         /* Update the 1st LENGTH field */
3397                         write_buf[write_index] = (uint8_t)0xFF;
3398                     }
3399                     break;
3400                 }
3401
3402                 case WR_LEN_2_VALUE:
3403                 {
3404                     /* Update the 2nd LENGTH field */
3405                     write_buf[write_index] = (uint8_t)
3406                                 (psNdefMap->ApduBuffIndex >> BYTE_SIZE);
3407                     break;
3408                 }
3409
3410                 case WR_LEN_3_VALUE:
3411                 {
3412                     /* Update the 3rd LENGTH field */
3413                     write_buf[write_index] = (uint8_t)
3414                                 (psNdefMap->ApduBuffIndex &
3415                                 TOPAZ_BYTE_LENGTH_MASK);
3416                     /* Exit the loop */
3417                     exit_while = TRUE;
3418                     break;
3419                 }
3420
3421                 default:
3422                 {
3423                     /* Invalid case */
3424                     break;
3425                 }
3426             }
3427             write_index = (uint16_t)(write_index + 1);
3428             if (
3429                 /* As the write is done for 8 bytes, the write index cant
3430                     go for more than or equal to 8 bytes, if it reaches 8 bytes
3431                     then sequence shall not be incrmented */
3432                 (TOPAZ_WRITE_8_DATA_LENGTH != write_index) &&
3433                 /* If the last length field byte is updated then the
3434                     write sequence shall not be incremented */
3435                 (WR_LEN_3_VALUE != write_seq) &&
3436                 /* Check added if the write length is less than 0xFF.
3437                     If length is less than 0xFF, then write sequence
3438                     shall not be incremented */
3439                 (write_len >= 0xFF)
3440                 )
3441             {
3442                 /* Sequence is incremented to the next level */
3443                 write_seq = (phFriNfc_Tpz_WrSeq_t)(write_seq + 1);
3444             }
3445             /* Byte number is incremented */
3446             ps_tpz_info->ByteNumber = (uint8_t)
3447                             (ps_tpz_info->ByteNumber + 1);
3448         }
3449         else
3450         {
3451
3452             if (skip_size >= (TOPAZ_WRITE_8_DATA_LENGTH - write_index))
3453             {
3454                 skip_size = (uint16_t)(skip_size - (TOPAZ_WRITE_8_DATA_LENGTH
3455                             - write_index));
3456                 write_index = (uint16_t)TOPAZ_WRITE_8_DATA_LENGTH;
3457             }
3458             else
3459             {
3460                 ps_tpz_info->ByteNumber = (uint8_t)
3461                             (ps_tpz_info->ByteNumber + skip_size);
3462                 write_index = (uint16_t)(write_index + skip_size);
3463                 skip_size = 0;
3464             }
3465
3466         }
3467     }
3468
3469     ps_tpz_info->WriteSeq = (uint8_t)write_seq;
3470
3471 #ifdef TOPAZ_RAW_SUPPORT
3472     *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
3473 #else
3474     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
3475 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
3476
3477     result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, write_buf,
3478                                             sizeof (write_buf));
3479     return result;
3480 }
3481
3482
3483
3484 static
3485 NFCSTATUS
3486 phFriNfc_Tpz_H_UpdateLenFieldZeroAfterRead (
3487     phFriNfc_NdefMap_t          *psNdefMap)
3488 {
3489     /* This function is called, only when the LENGTH field has to be updated
3490         with the 0 */
3491     NFCSTATUS                           result = NFCSTATUS_SUCCESS;
3492     phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
3493     uint16_t                            write_len = 0;
3494     uint16_t                            write_index = 0;
3495     uint16_t                            prev_apdu_index = 0;
3496     uint16_t                            byte_addr = 0;
3497     phFriNfc_Tpz_WrSeq_t                write_seq;
3498     /* This variable is kept static because if the size to skip LOCK or RESERVED
3499         bytes extends to next read then it shall be stored and used to skip the next
3500         read bytes
3501     */
3502     static uint16_t                     skip_size = 0;
3503     uint8_t                             write_buf[TOPAZ_WRITE_8_DATA_LENGTH];
3504
3505     ps_tpz_info = &(psNdefMap->TopazContainer);
3506     write_len = (uint16_t)((psNdefMap->ApduBufferSize < ps_tpz_info->NDEFRWSize) ?
3507                 psNdefMap->ApduBufferSize : ps_tpz_info->NDEFRWSize);
3508
3509     psNdefMap->State = PH_FRINFC_TOPAZ_STATE_WRITE;
3510
3511     (void)memcpy ((void *)write_buf, (void *)psNdefMap->SendRecvBuf,
3512                     TOPAZ_WRITE_8_DATA_LENGTH);
3513
3514     prev_apdu_index = psNdefMap->ApduBuffIndex;
3515     write_seq = (phFriNfc_Tpz_WrSeq_t)ps_tpz_info->WriteSeq;
3516
3517     if (WR_LEN_1_0 == write_seq)
3518     {
3519          /* First LENGTH field is geting updated, so the skip size
3520             reset is done */
3521         skip_size = 0;
3522     }
3523
3524     if (0 != ps_tpz_info->ByteNumber)
3525     {
3526         /* Byte Number is not 0, means that some data shall not be overwriteen till
3527             that position in the block */
3528         write_index = (uint16_t)(write_index + ps_tpz_info->ByteNumber);
3529         ps_tpz_info->ByteNumber = 0;
3530     }
3531
3532     if (0 != skip_size)
3533     {
3534         /* This is possible after updating the FIRST length field
3535             skip size is skipped because of the pending LOCK or
3536             RESERVED bytes
3537         */
3538         write_index = (uint16_t)(write_index + skip_size);
3539     }
3540
3541     while ((write_index < TOPAZ_WRITE_8_DATA_LENGTH) &&
3542         (write_len != psNdefMap->ApduBuffIndex))
3543     {
3544         skip_size = 0;
3545         byte_addr = TOPAZ_BYTE_ADR_FROM_BLK (ps_tpz_info->CurrentBlock,
3546                                             ps_tpz_info->ByteNumber);
3547         skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap, byte_addr);
3548
3549         if (0 == skip_size)
3550         {
3551             switch (write_seq)
3552             {
3553                 case WR_LEN_1_0:
3554                 {
3555                     /* First sequence is always to update 1st LENGTH field
3556                         of the TLV */
3557                     write_buf[write_index] = 0x00;
3558                     write_index = (uint16_t)(write_index + 1);
3559                     if (write_len < 0xFF)
3560                     {
3561                         /* LENGTH field is only 1 byte, so update change the sequence to
3562                             update user data */
3563                         write_seq = WR_DATA;
3564                     }
3565                     else
3566                     {
3567                         /* Go to the next LENGTH field to update */
3568                         write_seq = (phFriNfc_Tpz_WrSeq_t)((TOPAZ_WRITE_8_DATA_LENGTH !=
3569                                     write_index) ?
3570                                     (write_seq + 1) : write_seq);
3571                     }
3572                     break;
3573                 }
3574
3575                 case WR_LEN_2_0:
3576                 case WR_LEN_3_0:
3577                 {
3578                     /* Update 2nd and 3rd LEGNTH field */
3579                     write_buf[write_index] = 0x00;
3580                     write_index = (uint16_t)(write_index + 1);
3581                     write_seq = (phFriNfc_Tpz_WrSeq_t)((TOPAZ_WRITE_8_DATA_LENGTH !=
3582                                 write_index) ?
3583                                 (write_seq + 1) : write_seq);
3584                     break;
3585                 }
3586
3587                 case WR_DATA:
3588                 default:
3589                 {
3590                     /* Update the buffer by the user data */
3591                     write_buf[write_index] =
3592                             psNdefMap->ApduBuffer[psNdefMap->ApduBuffIndex];
3593
3594                     write_index = (uint16_t)(write_index + 1);
3595                     psNdefMap->ApduBuffIndex = (uint16_t)
3596                                         (psNdefMap->ApduBuffIndex + 1);
3597                     break;
3598                 }
3599
3600             }
3601
3602             ps_tpz_info->ByteNumber = (uint8_t)
3603                             (ps_tpz_info->ByteNumber + 1);
3604         }
3605         else
3606         {
3607             /* LOCK and MEMORY bytes are found */
3608             if (skip_size >= (TOPAZ_WRITE_8_DATA_LENGTH - write_index))
3609             {
3610                 /* skip size has exceeded the block number, so calculate the
3611                 remaining skip size  */
3612                 skip_size = (uint16_t)(skip_size - (TOPAZ_WRITE_8_DATA_LENGTH
3613                             - write_index));
3614                 write_index = (uint16_t)TOPAZ_WRITE_8_DATA_LENGTH;
3615             }
3616             else
3617             {
3618                 /* skip the LOCK and MEMORY bytes size */
3619                 ps_tpz_info->ByteNumber = (uint8_t)
3620                             (ps_tpz_info->ByteNumber + skip_size);
3621                 write_index = (uint16_t)(write_index + skip_size);
3622                 skip_size = 0;
3623             }
3624         }
3625     }
3626
3627     if (psNdefMap->ApduBuffIndex == write_len)
3628     {
3629         /* User data has been completely copied and it is ready to write, so
3630             change the sequence */
3631         ps_tpz_info->WriteSeq = (uint8_t)WR_DATA;
3632     }
3633     else if ((WR_DATA == write_seq) && (prev_apdu_index ==
3634         psNdefMap->ApduBuffIndex))
3635     {
3636         /* The user data has not been written, only the LENGTH field is
3637             updated */
3638         ps_tpz_info->WriteSeq = (uint8_t)((write_len < 0xFF) ?
3639                                 WR_LEN_1_0 : WR_LEN_3_0);
3640     }
3641     else
3642     {
3643         /*  Update the sequence in the context */
3644         ps_tpz_info->WriteSeq = (uint8_t)write_seq;
3645     }
3646
3647     ps_tpz_info->ByteNumber = 0;
3648
3649 #ifdef TOPAZ_RAW_SUPPORT
3650     *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
3651 #else
3652     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
3653 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
3654
3655     result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, write_buf,
3656                                             sizeof (write_buf));
3657     return result;
3658 }
3659
3660 static
3661 NFCSTATUS
3662 phFriNfc_Tpz_H_RdForWrite (
3663     phFriNfc_NdefMap_t          *psNdefMap)
3664 {
3665     NFCSTATUS                           result = NFCSTATUS_SUCCESS;
3666     phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
3667     phFriNfc_Tpz_WrSeq_t                write_seq;
3668     uint16_t                            byte_addr = 0;
3669     uint8_t                             exit_while = FALSE;
3670     uint16_t                            skip_size = 0;
3671
3672     ps_tpz_info = &(psNdefMap->TopazContainer);
3673     write_seq = (phFriNfc_Tpz_WrSeq_t)(ps_tpz_info->WriteSeq);
3674
3675 #ifdef TOPAZ_RAW_SUPPORT
3676
3677     *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_READ8;
3678
3679 #else
3680
3681     psNdefMap->Cmd.JewelCmd = phHal_eJewel_Read8;
3682
3683 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
3684
3685     psNdefMap->State = PH_FRINFC_TOPAZ_STATE_RD_FOR_WR_NDEF;
3686
3687     switch (write_seq)
3688     {
3689         case WR_LEN_1_0:
3690         case WR_LEN_1_VALUE:
3691         {
3692             byte_addr = (ps_tpz_info->NdefTLVByteAddress + 1);
3693
3694             /* This loop is to skip the lock amd reserved bytes */
3695             while (FALSE == exit_while)
3696             {
3697                 if (TOPAZ_STATIC_LOCK_FIRST_BLOCK_NO ==
3698                     TOPAZ_BLK_FROM_BYTE_ADR (byte_addr))
3699                 {
3700                     byte_addr = (uint16_t)(byte_addr +
3701                                 TOPAZ_STATIC_LOCK_RES_BYTES);
3702                 }
3703                 skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap,
3704                                                             byte_addr);
3705                 if (0 != skip_size)
3706                 {
3707                     byte_addr = (uint16_t)(byte_addr + skip_size);
3708
3709
3710                 }
3711                 else
3712                 {
3713                     exit_while = TRUE;
3714                 }
3715             }
3716             break;
3717         }
3718
3719         case WR_LEN_2_0:
3720         case WR_LEN_3_0:
3721         case WR_LEN_2_VALUE:
3722         case WR_LEN_3_VALUE:
3723         {
3724             byte_addr = (uint16_t)TOPAZ_BYTE_ADR_FROM_BLK (ps_tpz_info->CurrentBlock,
3725                                                     ps_tpz_info->ByteNumber);
3726             /* This loop is for to skip the lock amd reserved bytes */
3727             while (FALSE == exit_while)
3728             {
3729                 skip_size = phFriNfc_Tpz_H_GetSkipSize (psNdefMap,
3730                                                             byte_addr);
3731                 if (0 != skip_size)
3732                 {
3733                     byte_addr = (uint16_t)(byte_addr + skip_size);
3734                 }
3735                 else
3736                 {
3737                     exit_while = TRUE;
3738                 }
3739             }
3740             break;
3741         }
3742
3743         case WR_DATA_READ_REQD:
3744         {
3745             /* Lock or reserved bytes found bytes */
3746             byte_addr = (uint16_t)TOPAZ_BYTE_ADR_FROM_BLK (ps_tpz_info->CurrentBlock,
3747                                                     ps_tpz_info->ByteNumber);
3748             break;
3749         }
3750
3751         default:
3752         {
3753             break;
3754         }
3755     }
3756
3757     ps_tpz_info->CurrentBlock = (uint8_t)
3758                         TOPAZ_BLK_FROM_BYTE_ADR (byte_addr);
3759     ps_tpz_info->ByteNumber = (uint8_t)
3760                         TOPAZ_BYTE_OFFSET_FROM_BYTE_ADR (byte_addr);
3761
3762     result = phFriNfc_Tpz_H_NxpRead (psNdefMap);
3763
3764     return result;
3765 }
3766
3767 static
3768 uint16_t
3769 phFriNfc_Tpz_H_CompareLockBlocks (
3770     phFriNfc_NdefMap_t          *psNdefMap,
3771     uint8_t                     block_no,
3772     uint16_t                    *p_skip_size)
3773 {
3774     uint16_t                            return_addr = 0;
3775     phFriNfc_LockCntrlTLVCont_t         *ps_locktlv_info = NULL;
3776
3777     ps_locktlv_info = &(psNdefMap->LockTlv);
3778
3779     if (block_no == ps_locktlv_info->BlkNum)
3780     {
3781         /* ps_tpz_info->ByteNumber = (uint8_t)ps_locktlv_info->ByteNum; */
3782         *p_skip_size = ps_locktlv_info->Size;
3783         return_addr = ps_locktlv_info->ByteAddr;
3784     }
3785
3786     return return_addr;
3787 }
3788
3789 static
3790 uint16_t
3791 phFriNfc_Tpz_H_CompareMemBlocks (
3792     phFriNfc_NdefMap_t          *psNdefMap,
3793     uint8_t                     block_no,
3794     uint16_t                    *p_skip_size)
3795 {
3796     uint16_t                            return_addr = 0;
3797     phFriNfc_ResMemCntrlTLVCont_t       *ps_memtlv_info = NULL;
3798
3799     ps_memtlv_info = &(psNdefMap->MemTlv);
3800
3801     if (block_no == ps_memtlv_info->BlkNum)
3802     {
3803         /* ps_tpz_info->ByteNumber = (uint8_t)ps_memtlv_info->ByteNum; */
3804         *p_skip_size = ps_memtlv_info->Size;
3805         return_addr = ps_memtlv_info->ByteAddr;
3806     }
3807
3808     return return_addr;
3809 }
3810
3811
3812 static
3813 NFCSTATUS
3814 phFriNfc_Tpz_H_CopySendWrData (
3815     phFriNfc_NdefMap_t          *psNdefMap)
3816 {
3817     NFCSTATUS                           result = NFCSTATUS_SUCCESS;
3818     phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
3819     uint8_t                             write_buf[TOPAZ_WRITE_8_DATA_LENGTH];
3820     uint16_t                            write_len;
3821     uint8_t                             copy_length;
3822     uint16_t                            skip_size = 0;
3823
3824     ps_tpz_info = &(psNdefMap->TopazContainer);
3825     write_len = (uint16_t)((psNdefMap->ApduBufferSize < ps_tpz_info->NDEFRWSize) ?
3826                 psNdefMap->ApduBufferSize : ps_tpz_info->NDEFRWSize);
3827
3828     if (0 != phFriNfc_Tpz_H_CompareLockBlocks (psNdefMap,
3829                 ps_tpz_info->CurrentBlock, &skip_size))
3830     {
3831         ps_tpz_info->WriteSeq = (uint8_t)WR_DATA_READ_REQD;
3832         ps_tpz_info->ByteNumber = 0;
3833         result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
3834     }
3835     else if (0 != phFriNfc_Tpz_H_CompareMemBlocks (psNdefMap,
3836                 ps_tpz_info->CurrentBlock, &skip_size))
3837     {
3838         ps_tpz_info->WriteSeq = (uint8_t)WR_DATA_READ_REQD;
3839         ps_tpz_info->ByteNumber = 0;
3840         result = phFriNfc_Tpz_H_RdForWrite (psNdefMap);
3841     }
3842     else
3843     {
3844 #ifdef TOPAZ_RAW_SUPPORT
3845         *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
3846 #else
3847         psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
3848 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
3849         psNdefMap->State = (uint8_t)PH_FRINFC_TOPAZ_STATE_WRITE;
3850
3851         if ((write_len - psNdefMap->ApduBuffIndex) >= (uint16_t)TOPAZ_WRITE_8_DATA_LENGTH)
3852         {
3853             copy_length = (uint8_t)TOPAZ_WRITE_8_DATA_LENGTH;
3854             (void)memcpy ((void *)write_buf,
3855                     (void *)(psNdefMap->ApduBuffer + psNdefMap->ApduBuffIndex),
3856                     copy_length);
3857
3858             psNdefMap->ApduBuffIndex = (uint16_t)(psNdefMap->ApduBuffIndex +
3859                                         copy_length);
3860         }
3861         else
3862         {
3863             copy_length = (uint8_t)(write_len - psNdefMap->ApduBuffIndex);
3864
3865             (void)memcpy ((void *)write_buf,
3866                     (void *)(psNdefMap->ApduBuffer + psNdefMap->ApduBuffIndex),
3867                     TOPAZ_WRITE_8_DATA_LENGTH);
3868
3869             psNdefMap->ApduBuffIndex = (uint16_t)(psNdefMap->ApduBuffIndex +
3870                                         copy_length);
3871
3872             (void)memset ((void *)(write_buf + copy_length), 0x00,
3873                         (TOPAZ_WRITE_8_DATA_LENGTH - copy_length));
3874         }
3875
3876 #ifdef TOPAZ_RAW_SUPPORT
3877         *psNdefMap->SendRecvBuf = PH_FRINFC_TOPAZ_CMD_WRITE_E8;
3878 #else
3879         psNdefMap->Cmd.JewelCmd = phHal_eJewel_Write8E;
3880 #endif /* #ifdef TOPAZ_RAW_SUPPORT */
3881
3882         result = phFriNfc_Tpz_H_NxpWrite (psNdefMap, write_buf,
3883                                             sizeof (write_buf));
3884     }
3885
3886
3887     return result;
3888 }
3889
3890
3891 static
3892 NFCSTATUS
3893 phFriNfc_Tpz_H_ActualCardSize (
3894     phFriNfc_NdefMap_t          *psNdefMap)
3895 {
3896     NFCSTATUS                           result = NFCSTATUS_SUCCESS;
3897     phFriNfc_TopazCont_t                *ps_tpz_info = NULL;
3898     phFriNfc_LockCntrlTLVCont_t         *ps_locktlv_info = NULL;
3899     phFriNfc_ResMemCntrlTLVCont_t       *ps_memtlv_info = NULL;
3900     uint16_t                            ndef_value_byte_addr = 0;
3901     uint16_t                            ndef_read_write_size = 0;
3902
3903     ps_tpz_info = &(psNdefMap->TopazContainer);
3904     if (ps_tpz_info->ActualNDEFMsgSize > ps_tpz_info->RemainingSize)
3905     {
3906         ps_tpz_info->ActualNDEFMsgSize = 0;
3907         result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
3908                             NFCSTATUS_NO_NDEF_SUPPORT);
3909     }
3910     else
3911     {
3912         ndef_read_write_size = ps_tpz_info->RemainingSize;
3913         ndef_value_byte_addr = phFriNfc_Tpz_H_GetNDEFValueFieldAddrForRead
3914                                 (psNdefMap);
3915
3916         ps_locktlv_info = &(psNdefMap->LockTlv);
3917         if (ps_locktlv_info->ByteAddr > ndef_value_byte_addr)
3918         {
3919             ndef_read_write_size = (ndef_read_write_size -
3920                                     ps_locktlv_info->Size);
3921         }
3922
3923         ps_memtlv_info = &(psNdefMap->MemTlv);
3924         if (ps_memtlv_info->ByteAddr > ndef_value_byte_addr)
3925         {
3926             ndef_read_write_size = (ndef_read_write_size -
3927                                     ps_memtlv_info->Size);
3928         }
3929
3930         if (ps_tpz_info->ActualNDEFMsgSize > ndef_read_write_size)
3931         {
3932             ps_tpz_info->ActualNDEFMsgSize = 0;
3933             result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
3934                                 NFCSTATUS_NO_NDEF_SUPPORT);
3935         }
3936         else
3937         {
3938             ps_tpz_info->NDEFRWSize = (uint16_t)
3939                             ((ps_tpz_info->ActualNDEFMsgSize < 0xFF) ?
3940                             (ndef_read_write_size - 2) :
3941                             ndef_read_write_size);
3942         }
3943     }
3944
3945     return result;
3946 }
3947
3948 static
3949 NFCSTATUS
3950 phFriNfc_Tpz_H_ParseLockTLVType (
3951     phFriNfc_NdefMap_t          *psNdefMap,
3952     uint8_t                     *p_parse_data,
3953     uint16_t                    *p_parse_index,
3954     uint16_t                    total_len_to_parse,
3955     phFriNfc_Tpz_ParseSeq_t     *seq_to_execute)
3956 {
3957     NFCSTATUS                   result = NFCSTATUS_SUCCESS;
3958     uint16_t                    parse_index = *p_parse_index;
3959     phFriNfc_Tpz_ParseSeq_t     expected_seq = *seq_to_execute;
3960
3961     PHNFC_UNUSED_VARIABLE(psNdefMap);
3962     PHNFC_UNUSED_VARIABLE(total_len_to_parse);
3963
3964     switch (p_parse_data[parse_index])
3965     {
3966         case PH_FRINFC_TOPAZ_LOCK_CTRL_T:
3967         {
3968             expected_seq = LOCK_L_TLV;
3969             parse_index = (parse_index + 1);
3970             break;
3971         }
3972
3973         case PH_FRINFC_TOPAZ_NULL_T:
3974         {
3975             expected_seq = LOCK_T_TLV;
3976             parse_index = (parse_index + 1);
3977             break;
3978         }
3979
3980         default:
3981         {
3982             result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
3983                                 NFCSTATUS_NO_NDEF_SUPPORT);
3984             break;
3985         }
3986     }
3987
3988
3989     *seq_to_execute = expected_seq;
3990     *p_parse_index = parse_index;
3991     return result;
3992 }
3993
3994 static
3995 NFCSTATUS
3996 phFriNfc_Tpz_H_ParseMemTLVType (
3997     phFriNfc_NdefMap_t          *psNdefMap,
3998     uint8_t                     *p_parse_data,
3999     uint16_t                    *p_parse_index,
4000     uint16_t                    total_len_to_parse,
4001     phFriNfc_Tpz_ParseSeq_t     *seq_to_execute)
4002 {
4003     NFCSTATUS                   result = NFCSTATUS_SUCCESS;
4004     uint16_t                    parse_index = *p_parse_index;
4005     phFriNfc_Tpz_ParseSeq_t     expected_seq = *seq_to_execute;
4006
4007     PHNFC_UNUSED_VARIABLE(psNdefMap);
4008     PHNFC_UNUSED_VARIABLE(total_len_to_parse);
4009
4010     switch (p_parse_data[parse_index])
4011     {
4012         case PH_FRINFC_TOPAZ_LOCK_CTRL_T:
4013         {
4014             expected_seq = LOCK_L_TLV;
4015             parse_index = (parse_index + 1);
4016             break;
4017         }
4018
4019         case PH_FRINFC_TOPAZ_NULL_T:
4020         {
4021             expected_seq = MEM_T_TLV;
4022             parse_index = (parse_index + 1);
4023             break;
4024         }
4025
4026         case PH_FRINFC_TOPAZ_MEM_CTRL_T:
4027         {
4028             expected_seq = MEM_L_TLV;
4029             parse_index = (parse_index + 1);
4030             break;
4031         }
4032
4033         default:
4034         {
4035             result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
4036                                 NFCSTATUS_NO_NDEF_SUPPORT);
4037             break;
4038         }
4039     }
4040
4041     *seq_to_execute = expected_seq;
4042     *p_parse_index = parse_index;
4043     return result;
4044 }
4045
4046 static
4047 NFCSTATUS
4048 phFriNfc_Tpz_H_ParseNdefTLVType (
4049     phFriNfc_NdefMap_t          *psNdefMap,
4050     uint8_t                     *p_parse_data,
4051     uint16_t                    *p_parse_index,
4052     uint16_t                    total_len_to_parse,
4053     phFriNfc_Tpz_ParseSeq_t     *seq_to_execute)
4054 {
4055     NFCSTATUS                   result = NFCSTATUS_SUCCESS;
4056     uint16_t                    parse_index = *p_parse_index;
4057     phFriNfc_Tpz_ParseSeq_t     expected_seq = *seq_to_execute;
4058
4059     PHNFC_UNUSED_VARIABLE(psNdefMap);
4060     PHNFC_UNUSED_VARIABLE(total_len_to_parse);
4061
4062     switch (p_parse_data[parse_index])
4063     {
4064         case PH_FRINFC_TOPAZ_MEM_CTRL_T:
4065         {
4066             /* TYPE field of Memory control TLV is found.
4067                 This means that more than one memory control
4068                 TLV exists */
4069             expected_seq = MEM_L_TLV;
4070             parse_index = (parse_index + 1);
4071             break;
4072         }
4073
4074         case PH_FRINFC_TOPAZ_NULL_T:
4075         {
4076             /* Skip the NULL TLV */
4077             expected_seq = NDEF_T_TLV;
4078             parse_index = (parse_index + 1);
4079             break;
4080         }
4081
4082         case PH_FRINFC_TOPAZ_NDEF_T:
4083         {
4084             /* TYPE field of NDEF TLV found, so next expected
4085                 sequence is LENGTH field */
4086             expected_seq = NDEF_L_TLV;
4087             parse_index = (parse_index + 1);
4088             break;
4089         }
4090
4091         default:
4092         {
4093             /* Reset the sequence */
4094             expected_seq = LOCK_T_TLV;
4095             result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
4096                                 NFCSTATUS_NO_NDEF_SUPPORT);
4097             break;
4098         }
4099     }
4100
4101     *seq_to_execute = expected_seq;
4102     *p_parse_index = parse_index;
4103     return result;
4104 }
4105
4106 static
4107 uint16_t
4108 phFriNfc_Tpz_H_GetSkipSize (
4109     phFriNfc_NdefMap_t          *psNdefMap,
4110     uint16_t                    byte_adr_card)
4111 {
4112     uint16_t                        return_size = 0;
4113     phFriNfc_LockCntrlTLVCont_t     *ps_locktlv_info = NULL;
4114     phFriNfc_ResMemCntrlTLVCont_t   *ps_memtlv_info = NULL;
4115
4116     ps_locktlv_info = &(psNdefMap->LockTlv);
4117     ps_memtlv_info = &(psNdefMap->MemTlv);
4118
4119     /* If there are more than one LOCK CONTROL TLV, then
4120     ADD A LOOP HERE OF THE NUMBER OF TLVs FOUND */
4121     if (byte_adr_card == ps_locktlv_info->ByteAddr)
4122     {
4123         return_size = ps_locktlv_info->Size;
4124     }
4125
4126     /* If there are more than one MEMORY CONTROL TLV, then
4127         ADD A LOOP HERE OF THE NUMBER OF TLVs FOUND */
4128     if (byte_adr_card == ps_memtlv_info->ByteAddr)
4129     {
4130         return_size = ps_memtlv_info->Size;
4131     }
4132     return return_size;
4133 }
4134
4135 static
4136 NFCSTATUS
4137 phFriNfc_Tpz_H_GetLockBytesInfo (
4138     phFriNfc_NdefMap_t          *psNdefMap,
4139     uint8_t                     *p_lock_info)
4140 {
4141     NFCSTATUS                       result = NFCSTATUS_SUCCESS;
4142     phFriNfc_LockCntrlTLVCont_t     *ps_locktlv_info = NULL;
4143     uint8_t                         page_address = 0;
4144     uint8_t                         bytes_offset = 0;
4145     uint8_t                         lock_index = 0;
4146
4147     ps_locktlv_info = &(psNdefMap->LockTlv);
4148
4149     page_address = (uint8_t)(p_lock_info[lock_index] >> NIBBLE_SIZE);
4150     bytes_offset = (uint8_t)(p_lock_info[lock_index] & TOPAZ_NIBBLE_MASK);
4151
4152     lock_index = (lock_index + 1);
4153     ps_locktlv_info->Size = (uint16_t)
4154                             (((p_lock_info[lock_index] % TOPAZ_BYTE_SIZE_IN_BITS) > 0)?
4155                             ((p_lock_info[lock_index] / TOPAZ_BYTE_SIZE_IN_BITS) + 1) :
4156                             (p_lock_info[lock_index] / TOPAZ_BYTE_SIZE_IN_BITS));
4157
4158     lock_index = (lock_index + 1);
4159     ps_locktlv_info->BytesPerPage =
4160                             (p_lock_info[lock_index] & TOPAZ_NIBBLE_MASK);
4161     ps_locktlv_info->BytesLockedPerLockBit =
4162                             (p_lock_info[lock_index] >> NIBBLE_SIZE);
4163
4164     /* Apply the formula to calculate byte address
4165         ByteAddr = PageAddr*2^BytesPerPage + ByteOffset
4166     */
4167     ps_locktlv_info->ByteAddr = (uint16_t)((page_address
4168                                 * (1 << ps_locktlv_info->BytesPerPage))
4169                                 + bytes_offset);
4170
4171
4172     if (
4173         /* Out of bound memory check */
4174         ((ps_locktlv_info->ByteAddr + ps_locktlv_info->Size) >
4175         (uint16_t)(psNdefMap->TopazContainer.CCByteBuf[2] *
4176         TOPAZ_BYTES_PER_BLOCK)) ||
4177
4178         /* Check the static lock and reserved areas memory blocks */
4179         ((ps_locktlv_info->ByteAddr >= TOPAZ_STATIC_LOCK_RES_START) &&
4180         (ps_locktlv_info->ByteAddr < TOPAZ_STATIC_LOCK_RES_END)) ||
4181         (((ps_locktlv_info->ByteAddr + ps_locktlv_info->Size - 1) >=
4182         TOPAZ_STATIC_LOCK_RES_START) &&
4183         ((ps_locktlv_info->ByteAddr + ps_locktlv_info->Size - 1) <
4184         TOPAZ_STATIC_LOCK_RES_END))
4185         )
4186     {
4187         ps_locktlv_info->ByteAddr = 0;
4188         result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
4189                             NFCSTATUS_NO_NDEF_SUPPORT);
4190     }
4191     else
4192     {
4193         ps_locktlv_info->BlkNum = (ps_locktlv_info->ByteAddr /
4194                                     TOPAZ_BYTES_PER_BLOCK);
4195         ps_locktlv_info->ByteNum = (ps_locktlv_info->ByteAddr %
4196                                     TOPAZ_BYTES_PER_BLOCK);
4197     }
4198
4199     return result;
4200 }
4201
4202 static
4203 NFCSTATUS
4204 phFriNfc_Tpz_H_GetMemBytesInfo (
4205     phFriNfc_NdefMap_t          *psNdefMap,
4206     uint8_t                     *p_mem_info)
4207 {
4208     NFCSTATUS                       result = NFCSTATUS_SUCCESS;
4209     phFriNfc_ResMemCntrlTLVCont_t   *ps_memtlv_info = NULL;
4210     phFriNfc_LockCntrlTLVCont_t     *ps_locktlv_info = NULL;
4211     uint8_t                         page_address = 0;
4212     uint8_t                         bytes_offset = 0;
4213     uint8_t                         mem_index = 0;
4214
4215     ps_memtlv_info = &(psNdefMap->MemTlv);
4216     ps_locktlv_info = &(psNdefMap->LockTlv);
4217     page_address = (uint8_t)(p_mem_info[mem_index] >> NIBBLE_SIZE);
4218     bytes_offset = (uint8_t)(p_mem_info[mem_index] & TOPAZ_NIBBLE_MASK);
4219
4220     mem_index = (mem_index + 1);
4221     ps_memtlv_info->Size = (uint16_t)p_mem_info[mem_index];
4222
4223     mem_index = (mem_index + 1);
4224     ps_memtlv_info->BytesPerPage =
4225                             (p_mem_info[mem_index] & TOPAZ_NIBBLE_MASK);
4226
4227     /* Apply the formula to calculate byte address
4228         ByteAddr = PageAddr * 2^BytesPerPage + ByteOffset
4229     */
4230     ps_memtlv_info->ByteAddr = (uint16_t)((page_address
4231                             * (1 << ps_memtlv_info->BytesPerPage))
4232                             + bytes_offset);
4233
4234
4235     if (
4236         /* Check if the lock and memory bytes are overlapped */
4237         ((ps_memtlv_info->ByteAddr >= ps_locktlv_info->ByteAddr) &&
4238         (ps_memtlv_info->ByteAddr <=
4239         (ps_locktlv_info->ByteAddr + ps_locktlv_info->Size - 1))) ||
4240
4241         (((ps_memtlv_info->ByteAddr + ps_memtlv_info->Size - 1) >=
4242         ps_locktlv_info->ByteAddr) &&
4243         ((ps_memtlv_info->ByteAddr + ps_memtlv_info->Size - 1) <=
4244         (ps_locktlv_info->ByteAddr + ps_locktlv_info->Size - 1))) ||
4245
4246         /* Check the static lock and reserved areas memory blocks */
4247         ((ps_memtlv_info->ByteAddr >= TOPAZ_STATIC_LOCK_RES_START) &&
4248         (ps_memtlv_info->ByteAddr < TOPAZ_STATIC_LOCK_RES_END)) ||
4249         (((ps_memtlv_info->ByteAddr + ps_memtlv_info->Size - 1) >=
4250         TOPAZ_STATIC_LOCK_RES_START) &&
4251         ((ps_memtlv_info->ByteAddr + ps_memtlv_info->Size - 1) <
4252         TOPAZ_STATIC_LOCK_RES_END)) ||
4253
4254         /* Check if the memory address is out bound */
4255         ((ps_locktlv_info->ByteAddr + ps_locktlv_info->Size) >
4256         (uint16_t)(psNdefMap->TopazContainer.CCByteBuf[2] *
4257         TOPAZ_BYTES_PER_BLOCK))
4258         )
4259     {
4260         ps_memtlv_info->ByteAddr = 0;
4261         result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
4262                             NFCSTATUS_NO_NDEF_SUPPORT);
4263     }
4264     else
4265     {
4266         ps_memtlv_info->BlkNum = (ps_memtlv_info->ByteAddr /
4267                                     TOPAZ_BYTES_PER_BLOCK);
4268         ps_memtlv_info->ByteNum = (ps_memtlv_info->ByteAddr %
4269                                     TOPAZ_BYTES_PER_BLOCK);
4270     }
4271
4272     return result;
4273 }
4274
4275 #ifdef UNIT_TEST
4276 #include <phUnitTestNfc_TopazDynamic_static.c>
4277 #endif
4278
4279 #endif  /*#if !(defined(PH_FRINFC_MAP_TOPAZ_DISABLED ) || defined (PH_FRINFC_MAP_TOPAZ_DYNAMIC_DISABLED ))*/
4280
4281
4282