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