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_MifareUL.c
19 * \brief This component encapsulates read/write/check ndef/process functionalities,
20 * for the Mifare UL card.
21 *
22 * Project: NFC-FRI
23 *
24 * $Date: Wed Feb 17 15:18:08 2010 $
25 * $Author: ing07385 $
26 * $Revision: 1.36 $
27 * $Aliases: NFC_FRI1.1_WK1007_R33_1,NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $
28 *
29 */
30
31 #ifndef PH_FRINFC_MAP_MIFAREUL_DISABLED
32
33 #include <phFriNfc_NdefMap.h>
34 #include <phFriNfc_MifareULMap.h>
35 #include <phFriNfc_MapTools.h>
36 #include <phFriNfc_OvrHal.h>
37 #include <phFriNfc.h>
38
39
40 /*! \ingroup grp_file_attributes
41 * \name NDEF Mapping
42 *
43 * File: \ref phFriNfc_MifareUL.c
44 *
45 */
46 /*@{*/
47 #define PHFRINFCNDEFMAP_FILEREVISION "$Revision: 1.35 $"
48 #define PHFRINFCNDEFMAP_FILEALIASES "$Aliases: NFC_FRI1.1_WK1007_R33_1,NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $"
49 /*@}*/
50 /* Completion Helper */
51 static void phFriNfc_MifareUL_H_Complete(phFriNfc_NdefMap_t *NdefMap,
52 NFCSTATUS Status);
53
54 /*!
55 * \brief \copydoc page_ovr Helper function for Mifare UL. This function reads
56 * a 16 bytes from the card.
57 */
58 static NFCSTATUS phFriNfc_MfUL_H_Rd16Bytes( phFriNfc_NdefMap_t *NdefMap);
59
60 /*!
61 * \brief \copydoc page_ovr Helper function for Mifare UL. This function is
62 * to find NDEF TLV
63 */
64 static NFCSTATUS phFriNfc_MfUL_H_findNDEFTLV(phFriNfc_NdefMap_t *NdefMap,
65 uint8_t *CRFlag);
66
67 /*!
68 * \brief \copydoc page_ovr Helper function for Mifare UL. This function is
69 * to check the completing the reading 16 bytes
70 */
71 static NFCSTATUS phFriNfc_MfUL_H_Chk16Bytes(phFriNfc_NdefMap_t *NdefMap,
72 uint16_t TempLength);
73
74
75 /*!
76 * \brief \copydoc page_ovr Helper function for Mifare UL. This function is
77 * to read 16 bytes for the finding the ndef TLV
78 */
79 static NFCSTATUS phFriNfc_MfUL_H_RdCardfindNdefTLV( phFriNfc_NdefMap_t *NdefMap,
80 uint8_t BlockNo);
81
82 /*!
83 * \brief \copydoc page_ovr Helper function for Mifare UL. This function is
84 * to check the remaining size of the 3 byte of length field in TLV
85 */
86 static NFCSTATUS phFriNfc_MfUL_H_ChkRemainTLV(phFriNfc_NdefMap_t *NdefMap,
87 uint8_t *CRFlag);
88
89 /*!
90 * \brief \copydoc page_ovr Helper function for Mifare UL. This function is
91 * to byte and block number of the next TLV in the card and updating the
92 * remaining free space in the card
93 */
94 static void phFriNfc_MfUL_H_UpdateLen(phFriNfc_NdefMap_t *NdefMap,
95 uint16_t DataLen);
96
97 /*!
98 * \brief \copydoc page_ovr Helper function for Mifare UL. Depending on the
99 * operation (read/write/check ndef), the next function is called
100 */
101 static NFCSTATUS phFriNfc_MfUL_H_NxtOp(phFriNfc_NdefMap_t *NdefMap,
102 uint8_t *CRFlag);
103
104 /*!
105 * \brief \copydoc page_ovr Helper function for Mifare UL function. This
106 * function is to copy the read bytes to the internal "ReadBuf" buffer
107 */
108 static NFCSTATUS phFriNfc_MfUL_H_CopyRdBytes(phFriNfc_NdefMap_t *NdefMap);
109
110 /*!
111 * \brief \copydoc page_ovr Helper function for Mifare UL function. This
112 * function is to copy the read bytes to the user buffer
113 */
114 static NFCSTATUS phFriNfc_MfUL_H_CpDataToUserBuf(phFriNfc_NdefMap_t *NdefMap);
115
116 /*!
117 * \brief \copydoc page_ovr Helper function for Mifare UL function. This
118 * function is to write 4 bytes to 1 block in the card
119 */
120 static NFCSTATUS phFriNfc_MfUL_H_Wr4bytes(phFriNfc_NdefMap_t *NdefMap);
121
122 /*!
123 * \brief \copydoc page_ovr Helper function for Mifare UL function. This
124 * function is to check the CC bytes in block 3 card
125 */
126 static NFCSTATUS phFriNfc_MfUL_H_ChkCCBytes(phFriNfc_NdefMap_t *NdefMap);
127
128 /*!
129 * \brief \copydoc page_ovr Helper function for Mifare UL function. This
130 * function is to read the TLVs and then start writing
131 */
132 static NFCSTATUS phFriNfc_MfUL_H_RdBeforeWrite(phFriNfc_NdefMap_t *NdefMap);
133
134 /*!
135 * \brief \copydoc page_ovr Helper function for Mifare UL function. This
136 * function is to call write operation after reading the NDEF TLV block
137 */
138 static NFCSTATUS phFriNfc_MfUL_H_CallWrOp(phFriNfc_NdefMap_t *NdefMap);
139
140 /*!
141 * \brief \copydoc page_ovr Helper function for Mifare UL function. This
142 * function is to process the written data
143 */
144 static NFCSTATUS phFriNfc_MfUL_H_ProWrittenBytes(phFriNfc_NdefMap_t *NdefMap);
145
146 /*!
147 * \brief \copydoc page_ovr Helper function for Mifare UL function. This
148 * function is to fill the send buffer before write
149 */
150 static NFCSTATUS phFriNfc_MfUL_H_fillSendBufToWr(phFriNfc_NdefMap_t *NdefMap);
151
152 /*!
153 * \brief \copydoc page_ovr Helper function for Mifare UL function. This
154 * function is to update the length L of the TLV
155 */
156 static NFCSTATUS phFriNfc_MfUL_H_UpdateWrLen(phFriNfc_NdefMap_t *NdefMap);
157
158 /*!
159 * \brief \copydoc page_ovr Helper function for Mifare UL function. This
160 * function is to write the terminator TLV after writing all the bytes
161 */
162 static NFCSTATUS phFriNfc_MfUL_H_WrTermTLV(phFriNfc_NdefMap_t *NdefMap);
163
164 #ifdef LOCK_BITS_CHECK_ENABLE
165 static
166 void
167 phFriNfc_MfUL_H_ChkLockBits (
168 phFriNfc_NdefMap_t *NdefMap);
169 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
170
171 /*!
172 * \brief \copydoc select sector function for Mifare UL function. This
173 * function is to write the terminator TLV after writing all the bytes
174 */
175 static NFCSTATUS phFriNfc_MfUL_H_SelectSector(phFriNfc_NdefMap_t *NdefMap,
176 uint8_t SectorNo,
177 uint8_t CmdNo,
178 uint8_t NextState);
179
180
181
182 static void phFriNfc_MfUL_H_UpdateCrc( uint8_t ch,
183 uint16_t *lpwCrc );
184
185 static void phFriNfc_MfUL_H_ComputeCrc( int CRCType,
186 uint8_t *Data,
187 int Length,
188 uint8_t *TransmitFirst,
189 uint8_t *TransmitSecond
190 );
191
192 static void
193 phFriNfc_MfUL_CalcByteNum(phFriNfc_NdefMap_t *NdefMap);
194
195
196 #define CRC_A 0
197 #define CRC_B 1
198
199
phFriNfc_MifareUL_H_Reset(phFriNfc_NdefMap_t * NdefMap)200 NFCSTATUS phFriNfc_MifareUL_H_Reset(phFriNfc_NdefMap_t *NdefMap)
201 {
202 NFCSTATUS Result = NFCSTATUS_SUCCESS;
203
204 if ( NdefMap == NULL)
205 {
206 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_PARAMETER);
207 }
208 else
209 {
210 /* TLV structure initialisation */
211 NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_NDEFMAP_MFUL_VAL4;
212 NdefMap->TLVStruct.BytesRemainLinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;
213 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_NDEFMAP_MFUL_VAL0;
214 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;
215 NdefMap->TLVStruct.prevLenByteValue = PH_FRINFC_NDEFMAP_MFUL_VAL0;
216 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
217 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
218 NdefMap->TLVStruct.ActualSize = PH_FRINFC_NDEFMAP_MFUL_VAL0;
219 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
220 NdefMap->TLVStruct.WrLenFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
221
222 /* Mifare UL container initialisation */
223 NdefMap->MifareULContainer.ByteNumber = PH_FRINFC_NDEFMAP_MFUL_VAL0;
224 NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_MFUL_VAL0;
225 NdefMap->MifareULContainer.CurrentSector = PH_FRINFC_NDEFMAP_MFUL_VAL0;
226 NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_VAL0;
227 NdefMap->MifareULContainer.InternalLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
228 NdefMap->MifareULContainer.ReadBufIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0;
229 NdefMap->MifareULContainer.ReadWriteCompleteFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
230 NdefMap->MifareULContainer.RemainingSize = PH_FRINFC_NDEFMAP_MFUL_VAL0;
231
232 /* Fill all the structure related buffer to ZERO */
233 (void)memset(NdefMap->TLVStruct.NdefTLVBuffer,
234 PH_FRINFC_NDEFMAP_MFUL_VAL0,
235 PH_FRINFC_NDEFMAP_MFUL_VAL4);
236 (void)memset(NdefMap->MifareULContainer.Buffer,
237 PH_FRINFC_NDEFMAP_MFUL_VAL0,
238 PH_FRINFC_NDEFMAP_MFUL_VAL4);
239 (void)memset(NdefMap->MifareULContainer.InternalBuf,
240 PH_FRINFC_NDEFMAP_MFUL_VAL0,
241 PH_FRINFC_NDEFMAP_MFUL_VAL4);
242 (void)memset(NdefMap->MifareULContainer.ReadBuf,
243 PH_FRINFC_NDEFMAP_MFUL_VAL0,
244 PH_FRINFC_NDEFMAP_MFUL_VAL64);
245 }
246 return Result;
247 }
248
249 /*!
250 * \brief Initiates Reading of NDEF information from the Mifare UL.
251 *
252 * It performs a reset of the state and starts the action (state machine).
253 * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action
254 * has been triggered.
255 */
256
phFriNfc_MifareUL_RdNdef(phFriNfc_NdefMap_t * NdefMap,uint8_t * PacketData,uint32_t * PacketDataLength,uint8_t Offset)257 NFCSTATUS phFriNfc_MifareUL_RdNdef( phFriNfc_NdefMap_t *NdefMap,
258 uint8_t *PacketData,
259 uint32_t *PacketDataLength,
260 uint8_t Offset)
261 {
262 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
263 NFCSTATUS_INVALID_PARAMETER);
264
265 if((NdefMap != NULL) && (PacketData != NULL) && (PacketDataLength != NULL) &&
266 (*PacketDataLength != PH_FRINFC_NDEFMAP_MFUL_VAL0) &&
267 (Offset <= PH_FRINFC_NDEFMAP_SEEK_BEGIN) &&
268 (NdefMap->CompletionRoutine->CompletionRoutine != NULL) &&
269 (NdefMap->CompletionRoutine->Context != NULL ) &&
270 ((NdefMap->CardState != PH_NDEFMAP_CARD_STATE_INITIALIZED) &&
271 (NdefMap->CardState != PH_NDEFMAP_CARD_STATE_INVALID)))
272 {
273 /*Register PacketData to Data Buffer of NdefMap */
274 NdefMap->ApduBuffer = PacketData;
275 /*Register PacketDataLength to Data Length of NdefMap */
276 NdefMap->ApduBufferSize = *PacketDataLength ;
277 /* To return actual number of bytes read to the caller */
278 NdefMap->NumOfBytesRead = PacketDataLength ;
279 *NdefMap->NumOfBytesRead = 0;
280
281 if( (Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || ( NdefMap->PrevOperation ==
282 PH_FRINFC_NDEFMAP_WRITE_OPE))
283 {
284 NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
285 NdefMap->TLVStruct.NdefTLVFoundFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
286 NdefMap->TLVStruct.NdefTLVByte = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
287 NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
288 NdefMap->MifareULContainer.RemainingSize = NdefMap->CardMemSize;
289 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
290 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;
291 NdefMap->MifareULContainer.ReadBufIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0;
292 NdefMap->MifareULContainer.ReadWriteCompleteFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
293 }
294
295 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;
296 NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_CR_RD_NDEF;
297
298 if( (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&
299 (NdefMap->MifareULContainer.ReadWriteCompleteFlag ==
300 PH_FRINFC_NDEFMAP_MFUL_FLAG1))
301 {
302 /* No space on card for reading : we have already
303 reached the end of file !
304 Offset is set to Continue Operation */
305 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
306 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
307 }
308 else
309 {
310 NdefMap->Offset = (((Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN) &&
311 ( NdefMap->PrevOperation != PH_FRINFC_NDEFMAP_READ_OPE))?
312 PH_FRINFC_NDEFMAP_SEEK_BEGIN:
313 Offset);
314
315 Result = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
316 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap, NdefMap->MifareULContainer.CurrentBlock):
317 phFriNfc_MfUL_H_CpDataToUserBuf(NdefMap));
318 }
319 }
320 return Result;
321 }
322
323
324 /*!
325 * \brief Initiates writing of NDEF information to the Mifare UL.
326 *
327 * The function initiates the writing of NDEF information to a Mifare UL.
328 * It performs a reset of the state and starts the action (state machine).
329 * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action
330 * has been triggered.
331 */
332
phFriNfc_MifareUL_WrNdef(phFriNfc_NdefMap_t * NdefMap,uint8_t * PacketData,uint32_t * PacketDataLength,uint8_t Offset)333 NFCSTATUS phFriNfc_MifareUL_WrNdef( phFriNfc_NdefMap_t *NdefMap,
334 uint8_t *PacketData,
335 uint32_t *PacketDataLength,
336 uint8_t Offset)
337 {
338 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
339 NFCSTATUS_INVALID_PARAMETER);
340
341
342
343 if((NdefMap != NULL) && (PacketData != NULL) && (PacketDataLength != NULL) &&
344 (*PacketDataLength != PH_FRINFC_NDEFMAP_MFUL_VAL0) &&
345 (Offset <= PH_FRINFC_NDEFMAP_SEEK_BEGIN) &&
346 (NdefMap->CompletionRoutine->CompletionRoutine != NULL) &&
347 (NdefMap->CompletionRoutine->Context != NULL ) &&
348 ((NdefMap->CardState != PH_NDEFMAP_CARD_STATE_READ_ONLY) &&
349 (NdefMap->CardState != PH_NDEFMAP_CARD_STATE_INVALID)))
350 {
351 NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_CR_WR_NDEF;
352 /*Register PacketData to Data Buffer of NdefMap */
353 NdefMap->ApduBuffer = PacketData;
354 /*Register PacketDataLength to Data Length of NdefMap */
355 NdefMap->ApduBufferSize = *PacketDataLength ;
356 /* To return actual number of bytes read to the caller */
357 NdefMap->WrNdefPacketLength = PacketDataLength ;
358 *NdefMap->WrNdefPacketLength = 0;
359
360 if( (Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || ( NdefMap->PrevOperation ==
361 PH_FRINFC_NDEFMAP_READ_OPE))
362 {
363 NdefMap->MifareULContainer.CurrentSector = NdefMap->TLVStruct.NdefTLVSector;
364 NdefMap->MifareULContainer.CurrentBlock = NdefMap->TLVStruct.NdefTLVBlock;
365 NdefMap->TLVStruct.TcheckedinTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
366 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;
367 NdefMap->MifareULContainer.ReadBufIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0;
368 NdefMap->MifareULContainer.ReadWriteCompleteFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
369 NdefMap->TLVStruct.WrLenFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
370 NdefMap->MifareULContainer.InternalLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
371 NdefMap->MifareULContainer.RemainingSize =
372 (NdefMap->CardMemSize -
373 (((NdefMap->TLVStruct.NdefTLVBlock -
374 PH_FRINFC_NDEFMAP_MFUL_BYTE4) *
375 PH_FRINFC_NDEFMAP_MFUL_BYTE4) +
376 NdefMap->TLVStruct.NdefTLVByte +
377 PH_FRINFC_NDEFMAP_MFUL_VAL1));
378 }
379 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;
380 NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_CR_WR_NDEF;
381
382 if( (Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) &&
383 (NdefMap->MifareULContainer.ReadWriteCompleteFlag ==
384 PH_FRINFC_NDEFMAP_MFUL_FLAG1))
385 {
386 /* No space on card for reading : we have already
387 reached the end of file !
388 Offset is set to Continue Operation */
389 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
390 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
391 }
392 else
393 {
394 NdefMap->Offset = (((Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN) &&
395 ( NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE))?
396 PH_FRINFC_NDEFMAP_SEEK_BEGIN:
397 Offset);
398
399 if (NdefMap->TLVStruct.NdefTLVSector == 1)
400 {
401 NdefMap->MifareULContainer.CurrentSector = 1;
402
403 /* Change to sector 1 */
404 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
405 NdefMap->MifareULContainer.CurrentSector, 1,
406 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_1);
407
408 }
409 else
410 {
411 Result = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
412 phFriNfc_MfUL_H_RdBeforeWrite(NdefMap):
413 phFriNfc_MfUL_H_fillSendBufToWr(NdefMap));
414 }
415 }
416 }
417
418
419 return Result;
420 }
421
422
423
424 /*!
425 * \brief Check whether a particular Mifare UL is NDEF compliant.
426 *
427 * The function checks whether the peer device is NDEF compliant.
428 *
429 */
430
phFriNfc_MifareUL_ChkNdef(phFriNfc_NdefMap_t * NdefMap)431 NFCSTATUS phFriNfc_MifareUL_ChkNdef( phFriNfc_NdefMap_t *NdefMap)
432 {
433 NFCSTATUS status = NFCSTATUS_PENDING;
434 uint8_t index=0,
435 pSensRes[2] = {0};
436
437 /* set the data for additional data exchange*/
438 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
439 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0;
440 NdefMap->psDepAdditionalInfo.NAD = 0;
441
442 /*
443 * Changed
444 * Description: CardInfo106 replase
445 */
446
447 /* retrive remote card information */
448 pSensRes[0] = NdefMap->psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.AtqA[0];
449
450 NdefMap->TLVStruct.NdefTLVBlock = PH_FRINFC_NDEFMAP_MFUL_VAL4;
451 #ifdef LOCK_BITS_CHECK_ENABLE
452 NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK2;
453 #else
454 NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK3;
455 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
456 NdefMap->MifareULContainer.CRindex = PH_FRINFC_NDEFMAP_CR_CHK_NDEF;
457
458 /* Check for Mifare Bit information */
459 if (((pSensRes[0] & PH_FRINFC_NDEFMAP_MFUL_CHECK_RESP) == PH_FRINFC_NDEFMAP_MFUL_CHECK_RESP))
460 {
461 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_CHECK_OPE;
462 /* set the offset*/
463 NdefMap->SendRecvBuf[index] = NdefMap->MifareULContainer.CurrentBlock;
464
465 /*set the send length*/
466 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_MAX_SEND_BUF_TO_READ;
467
468 /* Change the state to check ndef compliancy */
469 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_CHK_NDEF_COMP;
470
471 /* Set the card type as Mifare UL */
472 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;
473
474 /* set the cmd to mifare read*/
475 /*
476 * Changed
477 * Description: phHal_eMifareCmdListMifareRead replace with phHal_eMifareRead
478 */
479 NdefMap->Cmd.MfCmd = phHal_eMifareRead;
480
481 /* Set the CR and context for Mifare operations*/
482 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareUL_Process;
483 NdefMap->MapCompletionInfo.Context = NdefMap;
484
485 /*Set the Length*/
486 *NdefMap->SendRecvLength = PH_FRINFC_NDEFMAP_MF_READ_BLOCK_SIZE;
487
488
489 /*Call the Overlapped HAL Transceive function */
490 status = phFriNfc_OvrHal_Transceive(NdefMap->LowerDevice,
491 &NdefMap->MapCompletionInfo,
492 NdefMap->psRemoteDevInfo,
493 NdefMap->Cmd,
494 &NdefMap->psDepAdditionalInfo,
495 NdefMap->SendRecvBuf,
496 NdefMap->SendLength,
497 NdefMap->SendRecvBuf,
498 NdefMap->SendRecvLength);
499 }
500 else
501 {
502 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_REMOTE_DEVICE);
503 }
504 return status;
505 }
506
507 static void
phFriNfc_MfUL_CalcByteNum(phFriNfc_NdefMap_t * NdefMap)508 phFriNfc_MfUL_CalcByteNum(phFriNfc_NdefMap_t *NdefMap)
509 {
510 uint8_t i = PH_FRINFC_NDEFMAP_MFUL_VAL0;
511 uint16_t TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
512
513
514 for (i = 0; i < 16; i++)
515 {
516 if ((NdefMap->MifareULContainer.ReadBuf[i] ==
517 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T) &&
518 ((NdefMap->MifareULContainer.ReadBuf[i + 1] ==
519 NdefMap->TLVStruct.ActualSize) ||
520 (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF)))
521 {
522 if (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF)
523 {
524 TemLength = NdefMap->MifareULContainer.ReadBuf[i + 2] |
525 ((uint16_t)NdefMap->MifareULContainer.ReadBuf[i + 3] << 8);
526
527 if (TemLength == NdefMap->TLVStruct.ActualSize)
528 {
529 NdefMap->MifareULContainer.ByteNumber = i + 1;
530 break;
531 }
532 }
533 else
534 {
535 NdefMap->MifareULContainer.ByteNumber = i + 1;
536 break;
537 }
538 }
539 }
540
541 return;
542 }
543
544
545 #ifdef LOCK_BITS_CHECK_ENABLE
546
547 #define MIF_UL_LOCK_BIT_CHECK 0xFF
548 #define MIF_UL_LOCK_BIT_0_VALUE 0x0F
549 #define MIF_UL_LOCK_BIT_1_VALUE 0x00
550
551 static
552 void
phFriNfc_MfUL_H_ChkLockBits(phFriNfc_NdefMap_t * NdefMap)553 phFriNfc_MfUL_H_ChkLockBits (
554 phFriNfc_NdefMap_t *NdefMap)
555 {
556 uint8_t index = 2;
557
558 if (((NdefMap->SendRecvBuf[index] &
559 MIF_UL_LOCK_BIT_CHECK) > MIF_UL_LOCK_BIT_0_VALUE) ||
560 (MIF_UL_LOCK_BIT_1_VALUE !=
561 (NdefMap->SendRecvBuf[(index + 1)] & MIF_UL_LOCK_BIT_CHECK)))
562 {
563 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;
564 }
565 }
566
567 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
568
569 /*!
570 * \brief Completion Routine, Processing function, needed to avoid long
571 * blocking.
572 * \note The lower (Overlapped HAL) layer must register a pointer to
573 * this function as a Completion
574 * Routine in order to be able to notify the component that an I/O
575 * has finished and data are ready to be processed.
576 *
577 */
578
phFriNfc_MifareUL_Process(void * Context,NFCSTATUS Status)579 void phFriNfc_MifareUL_Process( void *Context,
580 NFCSTATUS Status)
581
582 {
583
584 uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL0,
585 i = PH_FRINFC_NDEFMAP_MFUL_VAL0;
586 phFriNfc_NdefMap_t *NdefMap;
587 uint16_t TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
588 /*uint16_t TempByte = PH_FRINFC_NDEFMAP_MFUL_VAL0; */
589 static uint8_t CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
590
591 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
592
593 /* set the context to Map module */
594
595 NdefMap = (phFriNfc_NdefMap_t *)Context;
596
597 if ( Status == NFCSTATUS_SUCCESS )
598 {
599 switch (NdefMap->State)
600 {
601 case PH_FRINFC_NDEFMAP_MFUL_STATE_CHK_NDEF_COMP:
602 if (*NdefMap->SendRecvLength ==
603 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
604 {
605 /* Checks for the Ndef Compliency and validy of the memory size*/
606 Status = phFriNfc_MfUL_H_ChkCCBytes(NdefMap);
607 CRFlag = (uint8_t)((Status != NFCSTATUS_SUCCESS)?
608 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
609 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
610
611 #ifdef LOCK_BITS_CHECK_ENABLE
612
613 /* Check for lock bits */
614 if (NFCSTATUS_SUCCESS == Status)
615 {
616 phFriNfc_MfUL_H_ChkLockBits(NdefMap);
617 }
618
619 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
620
621 /* Find the NDEF TLV */
622 NdefMap->MifareULContainer.CurrentBlock = PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
623 Status = ((Status != NFCSTATUS_SUCCESS)?
624 Status:
625 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
626 NdefMap->MifareULContainer.CurrentBlock));
627 CRFlag = (uint8_t)(((Status != NFCSTATUS_PENDING ) ||
628 (CRFlag == PH_FRINFC_NDEFMAP_MFUL_FLAG1))?
629 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
630 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
631
632 #ifdef PH_HAL4_ENABLE
633 if ((Status != NFCSTATUS_PENDING ) &&
634 (Status != NFCSTATUS_SUCCESS))
635 {
636 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
637 }
638 #endif /* #ifdef PH_HAL4_ENABLE */
639 }
640 break;
641
642
643 case PH_FRINFC_NDEFMAP_MFUL_STATE_READ:
644 /* check the received bytes size equals 16 bytes*/
645 if (*NdefMap->SendRecvLength ==
646 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
647 {
648 if(NdefMap->MifareULContainer.ReadBufIndex <
649 (NdefMap->TLVStruct.ActualSize + (((NdefMap->TLVStruct.NdefTLVBlock -
650 PH_FRINFC_NDEFMAP_MFUL_BLOCK4)
651 * PH_FRINFC_NDEFMAP_MFUL_VAL4) + (NdefMap->TLVStruct.NdefTLVByte - 1) + 4)))
652
653 {
654 Status = phFriNfc_MfUL_H_CopyRdBytes(NdefMap);
655 }
656
657 if (Status == NFCSTATUS_SUCCESS)
658 {
659 if(NdefMap->MifareULContainer.ReadBufIndex >=
660 (NdefMap->TLVStruct.ActualSize + (((NdefMap->TLVStruct.NdefTLVBlock -
661 PH_FRINFC_NDEFMAP_MFUL_BLOCK4)
662 * PH_FRINFC_NDEFMAP_MFUL_VAL4) + (NdefMap->TLVStruct.NdefTLVByte - 1) + 4)))
663 {
664
665 phFriNfc_MfUL_CalcByteNum(NdefMap);
666 #if 0
667 for (i = 0; i < 16; i++)
668 {
669 if ((NdefMap->MifareULContainer.ReadBuf[i] ==
670 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T) &&
671 ((NdefMap->MifareULContainer.ReadBuf[i + 1] ==
672 NdefMap->TLVStruct.ActualSize) ||
673 (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF)))
674 {
675 if (NdefMap->MifareULContainer.ReadBuf[i + 1] == 0xFF)
676 {
677 TemLength = NdefMap->MifareULContainer.ReadBuf[i + 2] |
678 ((uint16_t)NdefMap->MifareULContainer.ReadBuf[i + 3] << 8);
679
680 if (TemLength == NdefMap->TLVStruct.ActualSize)
681 {
682 NdefMap->MifareULContainer.ByteNumber = i + 1;
683 break;
684 }
685 }
686 else
687 {
688 NdefMap->MifareULContainer.ByteNumber = i + 1;
689 break;
690 }
691 }
692 }
693 #endif
694
695 if (NdefMap->MifareULContainer.ReadBuf
696 [NdefMap->MifareULContainer.ByteNumber] == 0xFF)
697 {
698 NdefMap->MifareULContainer.ByteNumber =
699 NdefMap->MifareULContainer.ByteNumber + 3;
700 }
701 else
702 {
703 NdefMap->MifareULContainer.ByteNumber =
704 NdefMap->MifareULContainer.ByteNumber + 1;
705 }
706
707 Status = phFriNfc_MfUL_H_CpDataToUserBuf(NdefMap);
708 if (NdefMap->MifareULContainer.CurrentSector > 0)
709 {
710 NdefMap->MifareULContainer.CurrentSector = 0;
711 NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_READ;
712
713 Status = phFriNfc_MfUL_H_SelectSector(NdefMap,
714 NdefMap->MifareULContainer.CurrentSector, 1,
715 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);
716 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING )?
717 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
718 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
719 }
720 else
721 {
722 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
723 }
724 }
725 else
726 {
727 Status = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);
728 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
729 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
730 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
731 }
732 }
733 else
734 {
735
736 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
737 }
738 }
739 else
740 {
741 /* read error */
742 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
743 NFCSTATUS_INVALID_RECEIVE_LENGTH);
744 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
745 }
746 break;
747
748 case PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE:
749 Status = phFriNfc_MfUL_H_ProWrittenBytes(NdefMap);
750 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
751 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
752 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
753 break;
754
755 case PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP:
756 if (*NdefMap->SendRecvLength ==
757 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
758 {
759 switch(NdefMap->PrevOperation)
760 {
761 case PH_FRINFC_NDEFMAP_CHECK_OPE:
762 case PH_FRINFC_NDEFMAP_READ_OPE:
763 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
764 if(NdefMap->TLVStruct.NoLbytesinTLV >
765 PH_FRINFC_NDEFMAP_MFUL_VAL0)
766 {
767 Status = phFriNfc_MfUL_H_ChkRemainTLV(NdefMap, &CRFlag);
768 }
769 else
770 {
771 if(NdefMap->TLVStruct.NdefTLVFoundFlag !=
772 PH_FRINFC_NDEFMAP_MFUL_FLAG1)
773 {
774 /* Find the NDEF TLV */
775 Status = phFriNfc_MfUL_H_findNDEFTLV(NdefMap, &CRFlag);
776 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING )?
777 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
778 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
779 }
780 }
781 if((NdefMap->TLVStruct.NdefTLVFoundFlag ==
782 PH_FRINFC_NDEFMAP_MFUL_FLAG1) &&
783 (NdefMap->TLVStruct.NoLbytesinTLV ==
784 PH_FRINFC_NDEFMAP_MFUL_VAL0))
785 {
786 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
787 /* Ndef TLV found, so call the next function depending on the
788 check/read/write ndef operation */
789
790 if (NdefMap->MifareULContainer.CurrentSector > 0)
791 {
792 NdefMap->MifareULContainer.CurrentSector = 0;
793 NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP;
794
795 Status = phFriNfc_MfUL_H_SelectSector(NdefMap,
796 NdefMap->MifareULContainer.CurrentSector, 1,
797 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);
798 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING )?
799 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
800 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
801 }
802 else
803 {
804 /* Sector is 0 no need to send sector select */
805 Status = phFriNfc_MfUL_H_NxtOp(NdefMap, &CRFlag);
806 }
807 }
808
809 #ifdef PH_HAL4_ENABLE
810 if ((Status != NFCSTATUS_PENDING ) &&
811 (Status != NFCSTATUS_SUCCESS) &&
812 (PH_FRINFC_NDEFMAP_CHECK_OPE ==
813 NdefMap->PrevOperation))
814 {
815 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
816 }
817 #endif /* #ifdef PH_HAL4_ENABLE */
818 break;
819
820 case PH_FRINFC_NDEFMAP_WRITE_OPE:
821 /* Remove UpdateWrLen */
822 Status = ((NdefMap->TLVStruct.WrLenFlag ==
823 PH_FRINFC_NDEFMAP_MFUL_FLAG1)?
824 phFriNfc_MfUL_H_UpdateWrLen(NdefMap):
825 phFriNfc_MfUL_H_CallWrOp(NdefMap));
826 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
827 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
828 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
829 break;
830
831 default:
832 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
833 NFCSTATUS_INVALID_REMOTE_DEVICE);
834 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
835 break;
836
837 }
838 }
839 break;
840
841 case PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV:
842 Status = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);
843 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
844 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
845 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
846 break;
847
848 case PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV:
849 if(((((NdefMap->TLVStruct.NdefTLVByte -
850 PH_FRINFC_NDEFMAP_MFUL_VAL1) ==
851 PH_FRINFC_NDEFMAP_MFUL_VAL3) &&
852 (NdefMap->MifareULContainer.CurrentBlock ==
853 (NdefMap->TLVStruct.NdefTLVBlock +
854 PH_FRINFC_NDEFMAP_MFUL_VAL1))) ||
855 (((NdefMap->TLVStruct.NdefTLVByte -
856 PH_FRINFC_NDEFMAP_MFUL_VAL1) <
857 PH_FRINFC_NDEFMAP_MFUL_VAL3) && (
858 NdefMap->MifareULContainer.CurrentBlock ==
859 NdefMap->TLVStruct.NdefTLVBlock))))
860 {
861 (void)memcpy(NdefMap->MifareULContainer.InternalBuf,
862 NdefMap->MifareULContainer.Buffer,
863 NdefMap->MifareULContainer.InternalLength);
864 }
865 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
866 NdefMap->MifareULContainer.Buffer,
867 PH_FRINFC_NDEFMAP_MFUL_VAL4);
868
869 NdefMap->CardState =(uint8_t) ((NdefMap->CardState ==
870 PH_NDEFMAP_CARD_STATE_INITIALIZED)?
871 PH_NDEFMAP_CARD_STATE_READ_WRITE:
872 NdefMap->CardState);
873 NdefMap->ApduBuffIndex = PH_FRINFC_NDEFMAP_MFUL_VAL0;
874 NdefMap->NumOfBytesWritten = PH_FRINFC_NDEFMAP_MFUL_VAL0;
875
876 if (NdefMap->MifareULContainer.CurrentSector > 0)
877 {
878 /* Reset sector */
879 NdefMap->MifareULContainer.CurrentSector = 0;
880 NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV;
881
882 Status = phFriNfc_MfUL_H_SelectSector(NdefMap,
883 NdefMap->MifareULContainer.CurrentSector, 1,
884 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);
885 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
886 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
887 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
888 }
889 else
890 {
891 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
892 }
893
894 break;
895
896 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_1:
897 /* check the received bytes size equals 1 byte*/
898 if (*NdefMap->SendRecvLength ==
899 PH_FRINFC_NDEFMAP_MFUL_VAL1)
900 {
901 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)
902 {
903 /* Send second command */
904 Status = phFriNfc_MfUL_H_SelectSector(NdefMap,
905 NdefMap->MifareULContainer.CurrentSector, 2,
906 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_2);
907 }
908 else
909 {
910 /* read error */
911 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
912 NFCSTATUS_INVALID_FORMAT);
913 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
914 }
915 }
916 else
917 {
918 /* read error */
919 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
920 NFCSTATUS_INVALID_RECEIVE_LENGTH);
921 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
922
923 }
924 break;
925
926 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_2:
927 {
928 NdefMap->MifareULContainer.CurrentBlock +=
929 PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
930
931 Status = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
932 NdefMap->MifareULContainer.CurrentBlock);
933 }
934 break;
935
936 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1:
937 /* check the received bytes size equals 1 byte*/
938 if (*NdefMap->SendRecvLength ==
939 PH_FRINFC_NDEFMAP_MFUL_VAL1)
940 {
941 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)
942 {
943 /* Send second command */
944 Status = phFriNfc_MfUL_H_SelectSector(NdefMap,
945 NdefMap->MifareULContainer.CurrentSector, 2,
946 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_2);
947 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG0;
948 }
949 else
950 {
951 /* read error */
952 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
953 NFCSTATUS_INVALID_FORMAT);
954 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
955 }
956 }
957 else
958 {
959 /* read error */
960 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
961 NFCSTATUS_INVALID_RECEIVE_LENGTH);
962 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
963
964 }
965 break;
966
967 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_2:
968 {
969 if (NdefMap->MifareULContainer.CurrentBlock == 0xFF)
970 {
971 NdefMap->MifareULContainer.CurrentBlock = 0;
972 }
973 else
974 {
975 NdefMap->MifareULContainer.CurrentBlock =
976 (NdefMap->TLVStruct.NdefTLVBlock / 4) * 4;
977 }
978
979 Status = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);
980 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
981 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
982 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
983 }
984 break;
985
986 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_1:
987 /* check the received bytes size equals 1 byte*/
988 if (*NdefMap->SendRecvLength ==
989 PH_FRINFC_NDEFMAP_MFUL_VAL1)
990 {
991 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)
992 {
993 /* Send second command */
994 Status = phFriNfc_MfUL_H_SelectSector(NdefMap,
995 NdefMap->MifareULContainer.CurrentSector, 2,
996 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_2);
997 }
998 else
999 {
1000 /* read error */
1001 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1002 NFCSTATUS_INVALID_FORMAT);
1003 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1004 }
1005 }
1006 else
1007 {
1008 /* read error */
1009 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1010 NFCSTATUS_INVALID_RECEIVE_LENGTH);
1011 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1012
1013 }
1014 break;
1015
1016 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_2:
1017 {
1018 NdefMap->MifareULContainer.CurrentBlock = 0;
1019 Status = phFriNfc_MfUL_H_fillSendBufToWr(NdefMap);
1020
1021 if((Status == NFCSTATUS_SUCCESS) &&
1022 (NdefMap->TLVStruct.SetTermTLVFlag !=
1023 PH_FRINFC_NDEFMAP_MFUL_FLAG1) &&
1024 (NdefMap->MifareULContainer.RemainingSize >
1025 PH_FRINFC_NDEFMAP_MFUL_VAL0))
1026 {
1027 Status = phFriNfc_MfUL_H_WrTermTLV(NdefMap);
1028 }
1029 else
1030 {
1031 if((Status == NFCSTATUS_SUCCESS) &&
1032 (NdefMap->TLVStruct.SetTermTLVFlag ==
1033 PH_FRINFC_NDEFMAP_MFUL_FLAG1))
1034 {
1035 Status = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);
1036 }
1037 }
1038
1039 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
1040 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
1041 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
1042 }
1043 break;
1044
1045 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_1:
1046 /* check the received bytes size equals 1 byte*/
1047 if (*NdefMap->SendRecvLength ==
1048 PH_FRINFC_NDEFMAP_MFUL_VAL1)
1049 {
1050 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)
1051 {
1052 /* Send second command */
1053 Status = phFriNfc_MfUL_H_SelectSector(NdefMap,
1054 NdefMap->MifareULContainer.CurrentSector, 2,
1055 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_2);
1056 }
1057 else
1058 {
1059 /* read error */
1060 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1061 NFCSTATUS_INVALID_FORMAT);
1062 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1063 }
1064 }
1065 else
1066 {
1067 /* read error */
1068 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1069 NFCSTATUS_INVALID_RECEIVE_LENGTH);
1070 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1071
1072 }
1073 break;
1074
1075 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_INIT_2:
1076 {
1077 Status = ((NdefMap->Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
1078 phFriNfc_MfUL_H_RdBeforeWrite(NdefMap):
1079 phFriNfc_MfUL_H_fillSendBufToWr(NdefMap));
1080
1081
1082 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
1083 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
1084 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
1085 }
1086 break;
1087
1088
1089 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_1:
1090 /* check the received bytes size equals 1 byte*/
1091 if (*NdefMap->SendRecvLength ==
1092 PH_FRINFC_NDEFMAP_MFUL_VAL1)
1093 {
1094 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)
1095 {
1096 /* Send second command */
1097 Status = phFriNfc_MfUL_H_SelectSector(NdefMap,
1098 NdefMap->MifareULContainer.CurrentSector, 2,
1099 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_2);
1100 }
1101 else
1102 {
1103 /* read error */
1104 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1105 NFCSTATUS_INVALID_FORMAT);
1106 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1107 }
1108 }
1109 else
1110 {
1111 /* read error */
1112 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1113 NFCSTATUS_INVALID_RECEIVE_LENGTH);
1114 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1115
1116 }
1117 break;
1118
1119 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_2:
1120 {
1121 NdefMap->MifareULContainer.CurrentBlock = 0;
1122
1123 NdefMap->SendRecvBuf[index] =
1124 NdefMap->MifareULContainer.CurrentBlock;
1125 index++;
1126 NdefMap->SendRecvBuf[index] =
1127 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
1128 index++;
1129
1130 if((((NdefMap->TLVStruct.NdefTLVByte -
1131 PH_FRINFC_NDEFMAP_MFUL_VAL1) == PH_FRINFC_NDEFMAP_MFUL_VAL0) ||
1132 ((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1)
1133 == PH_FRINFC_NDEFMAP_MFUL_VAL3)))
1134 {
1135 /* Length to know how many bytes has to be written to the card */
1136 TemLength = (((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) ==
1137 PH_FRINFC_NDEFMAP_MFUL_VAL0)?
1138 PH_FRINFC_NDEFMAP_MFUL_VAL2:
1139 PH_FRINFC_NDEFMAP_MFUL_VAL3);
1140
1141 if(NdefMap->ApduBufferSize >= TemLength)
1142 {
1143 /* Prepare the receive buffer */
1144 (void)memcpy(&(NdefMap->SendRecvBuf[
1145 index]),
1146 &(NdefMap->ApduBuffer[
1147 NdefMap->ApduBuffIndex]),
1148 TemLength);
1149
1150 /* Number of bytes written to the card from user buffer */
1151 NdefMap->NumOfBytesWritten = TemLength;
1152
1153 index = index+(uint8_t)TemLength;
1154 /* Exact number of bytes written in the card including TLV */
1155 *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);
1156 }
1157 else
1158 {
1159 /* Prepare the receive buffer */
1160 (void)memcpy(&(NdefMap->SendRecvBuf[
1161 index]),
1162 &(NdefMap->ApduBuffer[
1163 NdefMap->ApduBuffIndex]),
1164 (uint16_t)NdefMap->ApduBufferSize);
1165
1166 /* Number of bytes written to the card from user buffer */
1167 NdefMap->NumOfBytesWritten = (uint16_t)NdefMap->ApduBufferSize;
1168
1169 index= index +(uint8_t)NdefMap->ApduBufferSize;
1170 /* Exact number of bytes written in the card including TLV */
1171 *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);
1172
1173 for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; i++)
1174 {
1175 NdefMap->SendRecvBuf[i] = (uint8_t)((i == index)?
1176 PH_FRINFC_NDEFMAP_MFUL_TERMTLV:
1177 PH_FRINFC_NDEFMAP_MFUL_NULLTLV);
1178 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1179 }
1180 }
1181
1182 /* store the bytes in buffer till the bytes are
1183 written in a block */
1184 (void)memcpy(NdefMap->MifareULContainer.Buffer,
1185 &(NdefMap->SendRecvBuf[
1186 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
1187 (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK -
1188 PH_FRINFC_NDEFMAP_MFUL_VAL1));
1189
1190 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
1191 NdefMap->MifareULContainer.Buffer,
1192 (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK -
1193 PH_FRINFC_NDEFMAP_MFUL_VAL1));
1194
1195 /* Change the state to check ndef compliancy */
1196 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
1197
1198 Status = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
1199 }
1200
1201
1202 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
1203 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
1204 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
1205 }
1206 break;
1207
1208 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1:
1209 /* check the received bytes size equals 1 byte*/
1210 if (*NdefMap->SendRecvLength ==
1211 PH_FRINFC_NDEFMAP_MFUL_VAL1)
1212 {
1213 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] == 0x0A)
1214 {
1215 /* Send second command */
1216 Status = phFriNfc_MfUL_H_SelectSector(NdefMap,
1217 NdefMap->MifareULContainer.CurrentSector, 2,
1218 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_2);
1219 }
1220 else
1221 {
1222 /* read error */
1223 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1224 NFCSTATUS_INVALID_FORMAT);
1225 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1226 }
1227 }
1228 else
1229 {
1230 /* read error */
1231 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1232 NFCSTATUS_INVALID_RECEIVE_LENGTH);
1233 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1234
1235 }
1236 break;
1237
1238 case PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_2:
1239 {
1240 if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP)
1241 {
1242 Status = phFriNfc_MfUL_H_NxtOp(NdefMap, &CRFlag);
1243 }
1244 else if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_READ)
1245 {
1246 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1247 }
1248 else if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE)
1249 {
1250 Status = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);
1251 CRFlag = (uint8_t)((Status != NFCSTATUS_PENDING)?
1252 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
1253 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
1254 }
1255 else if (NdefMap->PrevState == PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV)
1256 {
1257 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1258 }
1259 else
1260 {
1261 /* read error */
1262 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1263 NFCSTATUS_READ_FAILED);
1264 CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1265
1266 }
1267 }
1268 break;
1269
1270 default:
1271 /*set the invalid state*/
1272 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST);
1273 phFriNfc_MifareUL_H_Complete(NdefMap, Status);
1274 break;
1275 }
1276 if(CRFlag == PH_FRINFC_NDEFMAP_MFUL_FLAG1)
1277 {
1278 /* call the CR routine*/
1279 phFriNfc_MifareUL_H_Complete(NdefMap, Status);
1280 }
1281 }
1282 else
1283 {
1284 phFriNfc_MifareUL_H_Complete(NdefMap,Status);
1285 }
1286 }
1287
phFriNfc_MfUL_H_ChkCCBytes(phFriNfc_NdefMap_t * NdefMap)1288 static NFCSTATUS phFriNfc_MfUL_H_ChkCCBytes(phFriNfc_NdefMap_t *NdefMap )
1289 {
1290 NFCSTATUS Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP,
1291 NFCSTATUS_NO_NDEF_SUPPORT);
1292
1293 #ifdef LOCK_BITS_CHECK_ENABLE
1294 switch(NdefMap->SendRecvBuf[7])
1295 #else
1296 switch(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE3])
1297 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
1298 {
1299 case PH_FRINFC_NDEFMAP_MFUL_CC_BYTE3_RW:
1300 /* This state can be either INITIALISED or READWRITE. but default
1301 is INITIALISED */
1302 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INITIALIZED;
1303 break;
1304
1305 case PH_FRINFC_NDEFMAP_MFUL_CC_BYTE3_RO:
1306 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;
1307 break;
1308
1309 default :
1310 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
1311 }
1312
1313
1314
1315 /* Check for Ndef compliancy : 0 and 1 byte spcifies the ndef compliancy
1316 2 byte specifies the version of the MF UL tag*/
1317 #ifdef LOCK_BITS_CHECK_ENABLE
1318 if(( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE4] ==
1319 #else
1320 if(( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE0] ==
1321 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
1322 PH_FRINFC_NDEFMAP_MFUL_CC_BYTE0) && (
1323 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INITIALIZED) ||
1324 (NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY)))
1325 {
1326 /* Check the version number */
1327 Result =phFriNfc_MapTool_ChkSpcVer( NdefMap,
1328 #ifdef LOCK_BITS_CHECK_ENABLE
1329 5);
1330
1331 #else
1332 PH_FRINFC_NDEFMAP_MFUL_BYTE1);
1333
1334 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
1335 #if 0
1336 #ifdef PH_NDEF_MIFARE_ULC
1337 if (Result == NFCSTATUS_SUCCESS)
1338 {
1339 #ifdef LOCK_BITS_CHECK_ENABLE
1340
1341 if (NdefMap->SendRecvBuf[6] == 0x06)
1342 {
1343 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;
1344 }
1345 else if (NdefMap->SendRecvBuf[6] == 0x12)
1346 {
1347 // NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD;
1348 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;
1349 }
1350
1351 #else /* #ifdef LOCK_BITS_CHECK_ENABLE */
1352
1353 if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] == 0x06)
1354 {
1355 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;
1356 }
1357 else if (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] == 0x12)
1358 {
1359 // NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_ULC_CARD;
1360 NdefMap->CardType = PH_FRINFC_NDEFMAP_MIFARE_UL_CARD;
1361 }
1362
1363 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
1364 else
1365 {
1366 Result = PHNFCSTVAL( CID_FRI_NFC_NDEF_MAP,
1367 NFCSTATUS_INVALID_REMOTE_DEVICE);
1368 }
1369 }
1370 #else
1371
1372 /* Check the CC header size: Only valid ones are
1373 0x06 for 48 bytes. */
1374 #ifdef LOCK_BITS_CHECK_ENABLE
1375 Result = ((( NdefMap->SendRecvBuf[6] !=
1376 #else /* #ifdef LOCK_BITS_CHECK_ENABLE */
1377 Result = ((( NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] !=
1378 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
1379 PH_FRINFC_NDEFMAP_MFUL_CC_BYTE2) || (Result !=
1380 NFCSTATUS_SUCCESS))?
1381 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1382 NFCSTATUS_INVALID_REMOTE_DEVICE)):
1383 Result);
1384 #endif /* #ifdef PH_NDEF_MIFARE_ULC */
1385 #endif
1386 NdefMap->MifareULContainer.RemainingSize =
1387 NdefMap->CardMemSize = ((Result == NFCSTATUS_SUCCESS)?
1388 #ifdef LOCK_BITS_CHECK_ENABLE
1389 (NdefMap->SendRecvBuf[6] *
1390 #else /* #ifdef LOCK_BITS_CHECK_ENABLE */
1391 (NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_BYTE2] *
1392 #endif /* #ifdef LOCK_BITS_CHECK_ENABLE */
1393 PH_FRINFC_NDEFMAP_MFUL_MUL8):
1394 NdefMap->CardMemSize);
1395
1396 if (NdefMap->CardMemSize > 256)
1397 {
1398 NdefMap->CardMemSize = NdefMap->CardMemSize - 2;
1399 NdefMap->MifareULContainer.RemainingSize = NdefMap->CardMemSize;
1400 }
1401
1402 }
1403 else
1404 {
1405 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
1406 }
1407
1408
1409 return Result;
1410 }
1411
1412 /*!
1413 * \brief this shall notify the integration software with respective
1414 * success/error status along with the completion routines.
1415 *
1416 * This routine is called from the mifareul process function.
1417 *
1418 */
1419
phFriNfc_MifareUL_H_Complete(phFriNfc_NdefMap_t * NdefMap,NFCSTATUS Status)1420 static void phFriNfc_MifareUL_H_Complete(phFriNfc_NdefMap_t *NdefMap,
1421 NFCSTATUS Status)
1422 {
1423 if(NdefMap!=NULL)
1424 {
1425 if((PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE == NdefMap->State)
1426 && (NFCSTATUS_SUCCESS != Status))
1427 {
1428 *NdefMap->WrNdefPacketLength = 0;
1429 }
1430 /* set the state back to the Reset_Init state*/
1431 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RESET_INIT;
1432
1433 /* set the completion routine*/
1434 NdefMap->CompletionRoutine[NdefMap->MifareULContainer.CRindex].
1435 CompletionRoutine(NdefMap->CompletionRoutine->Context, Status);
1436 }
1437 }
1438
phFriNfc_MfUL_H_Rd16Bytes(phFriNfc_NdefMap_t * NdefMap)1439 static NFCSTATUS phFriNfc_MfUL_H_Rd16Bytes( phFriNfc_NdefMap_t *NdefMap)
1440 {
1441 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1442 NFCSTATUS_INVALID_PARAMETER);
1443
1444 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_READ;
1445
1446 /* Set the previous operation flag to read. */
1447 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;
1448
1449 /* Have we already read the entire file? */
1450 if(NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize)
1451 {
1452 /* set the data for additional data exchange */
1453 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0;
1454 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0;
1455 NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0;
1456 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] =
1457 NdefMap->MifareULContainer.CurrentBlock;
1458 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL1;
1459 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
1460 /*
1461 * Changed
1462 * Description: replace with phHal_eMifareRead
1463 */
1464
1465 NdefMap->Cmd.MfCmd = phHal_eMifareRead;
1466
1467 /* Call the overlapped HAL Transceive function */
1468 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice,
1469 &NdefMap->MapCompletionInfo,
1470 NdefMap->psRemoteDevInfo,
1471 NdefMap->Cmd,
1472 &NdefMap->psDepAdditionalInfo,
1473 NdefMap->SendRecvBuf,
1474 NdefMap->SendLength,
1475 NdefMap->SendRecvBuf,
1476 NdefMap->SendRecvLength);
1477 }
1478 return Result;
1479 }
1480
phFriNfc_MfUL_H_Wr4bytes(phFriNfc_NdefMap_t * NdefMap)1481 static NFCSTATUS phFriNfc_MfUL_H_Wr4bytes( phFriNfc_NdefMap_t *NdefMap)
1482 {
1483 NFCSTATUS Result = NFCSTATUS_SUCCESS;
1484
1485 /* set the receive length*/
1486 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
1487
1488 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;
1489
1490 /*
1491 * Changed
1492 * Description: phHal_eMifareCmdListMifareWrite4 replace with phHal_eMifareWrite4
1493 */
1494 /* set the cmd to mifare read*/
1495 NdefMap->Cmd.MfCmd = phHal_eMifareWrite4;
1496
1497 /* Set the CR and context for Mifare operations*/
1498 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_MifareUL_Process;
1499 NdefMap->MapCompletionInfo.Context = NdefMap;
1500
1501 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK;
1502 /*Call the Overlapped HAL Transceive function */
1503 Result = phFriNfc_OvrHal_Transceive(NdefMap->LowerDevice,
1504 &NdefMap->MapCompletionInfo,
1505 NdefMap->psRemoteDevInfo,
1506 NdefMap->Cmd,
1507 &NdefMap->psDepAdditionalInfo,
1508 NdefMap->SendRecvBuf,
1509 NdefMap->SendLength,
1510 NdefMap->SendRecvBuf,
1511 NdefMap->SendRecvLength);
1512 return Result;
1513 }
1514
phFriNfc_MfUL_H_findNDEFTLV(phFriNfc_NdefMap_t * NdefMap,uint8_t * CRFlag)1515 static NFCSTATUS phFriNfc_MfUL_H_findNDEFTLV(phFriNfc_NdefMap_t *NdefMap,
1516 uint8_t *CRFlag)
1517 {
1518 NFCSTATUS Result = NFCSTATUS_SUCCESS;
1519 uint16_t ShiftLength = PH_FRINFC_NDEFMAP_MFUL_VAL0,
1520 TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0,
1521 Temp16Bytes = PH_FRINFC_NDEFMAP_MFUL_VAL0;
1522 Temp16Bytes = ((NdefMap->TLVStruct.NdefTLVByte > PH_FRINFC_NDEFMAP_MFUL_VAL0)?
1523 (NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1):
1524 NdefMap->TLVStruct.NdefTLVByte);
1525 for(;;)
1526 {
1527 if(NdefMap->SendRecvBuf[Temp16Bytes] ==
1528 PH_FRINFC_NDEFMAP_MFUL_NULLTLV)
1529 {
1530 NdefMap->MifareULContainer.RemainingSize -=
1531 PH_FRINFC_NDEFMAP_MFUL_VAL1;
1532 #ifdef PH_HAL4_ENABLE
1533 /* This check is added to know the remaining size in
1534 the card is not 0, if this is 0, then complete card has
1535 been read */
1536 if (NdefMap->MifareULContainer.RemainingSize ==
1537 PH_FRINFC_NDEFMAP_MFUL_VAL0)
1538 {
1539 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1540 NFCSTATUS_NO_NDEF_SUPPORT);
1541 break;
1542 }
1543 else
1544 {
1545 Result = NFCSTATUS_SUCCESS;
1546 }
1547 #else
1548 Result = ((NdefMap->MifareULContainer.RemainingSize ==
1549 PH_FRINFC_NDEFMAP_MFUL_VAL0)?
1550 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1551 NFCSTATUS_NO_NDEF_SUPPORT)):
1552 NFCSTATUS_SUCCESS);
1553 #endif /* #ifdef PH_HAL4_ENABLE */
1554 Temp16Bytes++;
1555 #ifdef PH_HAL4_ENABLE
1556 /* This code is added to read next 16 bytes. This means previous
1557 16 bytes read contains only NULL TLV, so read further to get the
1558 NDEF TLV */
1559 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1560 Temp16Bytes);
1561 if(NFCSTATUS_SUCCESS != Result)
1562 {
1563 NdefMap->TLVStruct.NdefTLVBlock =
1564 NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL4;
1565 break;
1566 }
1567 #endif /* #ifdef PH_HAL4_ENABLE */
1568 }
1569 else
1570 {
1571 Result = ((NdefMap->SendRecvBuf[Temp16Bytes] ==
1572 PH_FRINFC_NDEFMAP_MFUL_TERMTLV)?
1573 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1574 NFCSTATUS_NO_NDEF_SUPPORT)):
1575 NFCSTATUS_SUCCESS);
1576
1577 if(Result != NFCSTATUS_SUCCESS)
1578 {
1579 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1580 break;
1581 }
1582
1583 #ifdef PH_NDEF_MIFARE_ULC
1584 if ((NdefMap->SendRecvBuf[Temp16Bytes] ==
1585 PH_FRINFC_NDEFMAP_MFUL_LOCK_CTRL_TLV) ||
1586 (NdefMap->SendRecvBuf[Temp16Bytes] ==
1587 PH_FRINFC_NDEFMAP_MFUL_MEM_CTRL_TLV) )
1588 {
1589
1590 NdefMap->TLVStruct.NdefTLVByte =
1591 ((Temp16Bytes %
1592 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
1593 PH_FRINFC_NDEFMAP_MFUL_VAL1);
1594
1595 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1596 Temp16Bytes);
1597 if(Result != NFCSTATUS_SUCCESS)
1598 {
1599 NdefMap->TLVStruct.TcheckedinTLVFlag =
1600 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1601 NdefMap->TLVStruct.NoLbytesinTLV =
1602 PH_FRINFC_NDEFMAP_MFUL_VAL3;
1603 break;
1604 }
1605 Temp16Bytes++;
1606 NdefMap->MifareULContainer.RemainingSize -=
1607 PH_FRINFC_NDEFMAP_MFUL_VAL1;
1608
1609 if(NdefMap->MifareULContainer.RemainingSize ==
1610 PH_FRINFC_NDEFMAP_MFUL_VAL0)
1611 {
1612 Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1613 NFCSTATUS_NO_NDEF_SUPPORT));
1614 break;
1615 }
1616
1617 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1618 Temp16Bytes);
1619 if(Result != NFCSTATUS_SUCCESS)
1620 {
1621 NdefMap->TLVStruct.TcheckedinTLVFlag =
1622 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1623 NdefMap->TLVStruct.NoLbytesinTLV =
1624 PH_FRINFC_NDEFMAP_MFUL_VAL3;
1625 break;
1626 }
1627
1628
1629 /* If the value of the Length(L) in TLV is FF then enter else
1630 check for the card memory */
1631 if((NdefMap->SendRecvBuf[Temp16Bytes] ==
1632 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) ||
1633 ((NdefMap->SendRecvBuf[Temp16Bytes] ==
1634 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) &&
1635 (NdefMap->TLVStruct.NdefTLVFoundFlag !=
1636 PH_FRINFC_NDEFMAP_MFUL_FLAG1)))
1637 {
1638 /* In the present case, the card space is not greater
1639 than 0xFF */
1640 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1641 NFCSTATUS_NO_NDEF_SUPPORT);
1642
1643 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1644 break;
1645 }
1646 else
1647 {
1648 NdefMap->TLVStruct.BytesRemainLinTLV =
1649 NdefMap->SendRecvBuf[Temp16Bytes];
1650
1651 NdefMap->TLVStruct.ActualSize =
1652 NdefMap->SendRecvBuf[Temp16Bytes];
1653
1654 if((NdefMap->MifareULContainer.RemainingSize <
1655 NdefMap->SendRecvBuf[Temp16Bytes]) ||
1656 (NdefMap->MifareULContainer.RemainingSize <
1657 PH_FRINFC_NDEFMAP_MFUL_VAL2) ||
1658 (NdefMap->TLVStruct.BytesRemainLinTLV >
1659 (NdefMap->MifareULContainer.RemainingSize)) ||
1660 ((NdefMap->TLVStruct.BytesRemainLinTLV ==
1661 PH_FRINFC_NDEFMAP_MFUL_VAL0) &&
1662 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE)))
1663 {
1664 /* No NDEF TLV found */
1665 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1666 NFCSTATUS_NO_NDEF_SUPPORT);
1667 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1668 break;
1669 }
1670
1671 if(NdefMap->TLVStruct.NdefTLVFoundFlag !=
1672 PH_FRINFC_NDEFMAP_MFUL_FLAG1)
1673 {
1674 NdefMap->TLVStruct.NdefTLVByte =
1675 (((Temp16Bytes + PH_FRINFC_NDEFMAP_MFUL_VAL1 +
1676 NdefMap->SendRecvBuf[Temp16Bytes]) %
1677 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
1678 PH_FRINFC_NDEFMAP_MFUL_VAL1);
1679 #if 0
1680 NdefMap->TLVStruct.NdefTLVBlock =
1681 (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock
1682 + ((Temp16Bytes +
1683 NdefMap->SendRecvBuf[Temp16Bytes] + 1)/
1684 PH_FRINFC_NDEFMAP_MFUL_VAL4));
1685 #endif
1686 NdefMap->TLVStruct.NdefTLVBlock =
1687 (uint8_t)(((NdefMap->TLVStruct.NdefTLVBlock / PH_FRINFC_NDEFMAP_MFUL_VAL4) *
1688 PH_FRINFC_NDEFMAP_MFUL_VAL4)
1689 + ((Temp16Bytes + NdefMap->SendRecvBuf[Temp16Bytes] + 1)/
1690 PH_FRINFC_NDEFMAP_MFUL_VAL4));
1691
1692
1693 TemLength = (Temp16Bytes +
1694 NdefMap->SendRecvBuf[Temp16Bytes]);
1695
1696 NdefMap->MifareULContainer.RemainingSize =
1697 (NdefMap->MifareULContainer.RemainingSize -
1698 (NdefMap->SendRecvBuf[Temp16Bytes]
1699 + PH_FRINFC_NDEFMAP_MFUL_VAL1));
1700
1701 /* If the Length (L) in TLV < 16 bytes */
1702 Temp16Bytes = ((TemLength >=
1703 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
1704 PH_FRINFC_NDEFMAP_MFUL_VAL0:
1705 (TemLength +
1706 PH_FRINFC_NDEFMAP_MFUL_VAL1));
1707
1708 Result = ((TemLength >=
1709 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
1710 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
1711 NdefMap->TLVStruct.NdefTLVBlock):
1712 NFCSTATUS_SUCCESS);
1713
1714 if(TemLength >= PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
1715 {
1716 break;
1717 }
1718 TemLength = Temp16Bytes;
1719 }
1720 }
1721
1722
1723
1724
1725 #if 0
1726
1727 NdefMap->MifareULContainer.RemainingSize =
1728 (NdefMap->MifareULContainer.RemainingSize -
1729 (NdefMap->SendRecvBuf[Temp16Bytes + 1]
1730 + PH_FRINFC_NDEFMAP_MFUL_VAL2));
1731
1732 NdefMap->TLVStruct.NdefTLVBlock =
1733 (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock
1734 + ((Temp16Bytes +
1735 NdefMap->SendRecvBuf[Temp16Bytes + 1] + 2)/
1736 PH_FRINFC_NDEFMAP_MFUL_VAL4));
1737
1738
1739 Temp16Bytes = Temp16Bytes +
1740 NdefMap->SendRecvBuf[Temp16Bytes + 1] + 2;
1741 #endif
1742 }
1743 #endif /* #ifdef PH_NDEF_MIFARE_ULC */
1744 else {
1745
1746 /* Check the byte for 0x03 Type of NDEF TLV */
1747 NdefMap->TLVStruct.NdefTLVFoundFlag =
1748 ((NdefMap->SendRecvBuf[Temp16Bytes] ==
1749 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T)?
1750 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
1751 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
1752
1753 if(NdefMap->TLVStruct.NdefTLVFoundFlag ==
1754 PH_FRINFC_NDEFMAP_MFUL_FLAG1)
1755 {
1756 ShiftLength = (Temp16Bytes +
1757 NdefMap->SendRecvBuf[Temp16Bytes]);
1758
1759 NdefMap->TLVStruct.NdefTLVByte =
1760 ((Temp16Bytes %
1761 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
1762 PH_FRINFC_NDEFMAP_MFUL_VAL1);
1763
1764 NdefMap->TLVStruct.NdefTLVBlock =
1765 (uint8_t)(((NdefMap->TLVStruct.NdefTLVBlock /4) * 4)
1766 + (Temp16Bytes)/
1767 PH_FRINFC_NDEFMAP_MFUL_VAL4);
1768
1769 NdefMap->TLVStruct.NdefTLVSector = NdefMap->MifareULContainer.CurrentSector;
1770
1771 }
1772 #ifdef PH_HAL4_ENABLE
1773 else
1774 {
1775 /* if the Type of the NDEF TLV is not found, then return
1776 error saying no ndef TLV found*/
1777 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1778 NFCSTATUS_NO_NDEF_SUPPORT);
1779 break;
1780 #if 0
1781 /* This change is added to continue the loop, if the Type of the
1782 NDEF TLV is not found
1783 16 bytes are read, so for each byte, there is a check for the
1784 Type (T) of the TLV, if T != 0x03, then increment the byte
1785 count and restart the loop, till the T = 0x03 is found or all
1786 the bytes in the card is completely read.
1787 */
1788 Temp16Bytes = (uint16_t)(Temp16Bytes + 1);
1789 NdefMap->MifareULContainer.RemainingSize -=
1790 PH_FRINFC_NDEFMAP_MFUL_VAL1;
1791 if (NdefMap->MifareULContainer.RemainingSize ==
1792 PH_FRINFC_NDEFMAP_MFUL_VAL0)
1793 {
1794 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1795 NFCSTATUS_NO_NDEF_SUPPORT);
1796 break;
1797 }
1798 else
1799 {
1800 Result = NFCSTATUS_SUCCESS;
1801 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1802 Temp16Bytes);
1803 if(NFCSTATUS_PENDING == Result)
1804 {
1805 break;
1806 }
1807 continue;
1808 }
1809 #endif /* #if 0 */
1810 }
1811 #endif /* #ifdef PH_HAL4_ENABLE */
1812
1813 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1814 Temp16Bytes);
1815 if(Result != NFCSTATUS_SUCCESS)
1816 {
1817 NdefMap->TLVStruct.TcheckedinTLVFlag =
1818 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1819 NdefMap->TLVStruct.NoLbytesinTLV =
1820 PH_FRINFC_NDEFMAP_MFUL_VAL3;
1821 break;
1822 }
1823 Temp16Bytes++;
1824 NdefMap->MifareULContainer.RemainingSize -=
1825 PH_FRINFC_NDEFMAP_MFUL_VAL1;
1826
1827 if(NdefMap->MifareULContainer.RemainingSize ==
1828 PH_FRINFC_NDEFMAP_MFUL_VAL0)
1829 {
1830 Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1831 NFCSTATUS_NO_NDEF_SUPPORT));
1832 break;
1833 }
1834
1835 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1836 Temp16Bytes);
1837 if(Result != NFCSTATUS_SUCCESS)
1838 {
1839 NdefMap->TLVStruct.TcheckedinTLVFlag =
1840 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1841 NdefMap->TLVStruct.NoLbytesinTLV =
1842 PH_FRINFC_NDEFMAP_MFUL_VAL3;
1843 break;
1844 }
1845
1846 /* If the value of the Length(L) in TLV is FF then enter else
1847 check for the card memory */
1848 if((NdefMap->SendRecvBuf[Temp16Bytes] ==
1849 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) ||
1850 ((NdefMap->SendRecvBuf[Temp16Bytes] ==
1851 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) &&
1852 (NdefMap->TLVStruct.NdefTLVFoundFlag !=
1853 PH_FRINFC_NDEFMAP_MFUL_FLAG1)))
1854 {
1855 /* In the present case, the card space is not greater
1856 than 0xFF */
1857 /*
1858 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1859 NFCSTATUS_NO_NDEF_SUPPORT);
1860
1861 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1862 break;
1863 */
1864
1865 Temp16Bytes++;
1866 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1867 Temp16Bytes);
1868 if(Result != NFCSTATUS_SUCCESS)
1869 {
1870 NdefMap->TLVStruct.TcheckedinTLVFlag =
1871 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1872 NdefMap->TLVStruct.NoLbytesinTLV =
1873 PH_FRINFC_NDEFMAP_MFUL_VAL2;
1874
1875 break;
1876 }
1877
1878 ShiftLength = (uint16_t) NdefMap->SendRecvBuf[Temp16Bytes];
1879 NdefMap->MifareULContainer.RemainingSize--;
1880
1881 Temp16Bytes++;
1882 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1883 Temp16Bytes);
1884 if(Result != NFCSTATUS_SUCCESS)
1885 {
1886 NdefMap->TLVStruct.TcheckedinTLVFlag =
1887 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1888 NdefMap->TLVStruct.NoLbytesinTLV =
1889 PH_FRINFC_NDEFMAP_MFUL_VAL1;
1890 NdefMap->TLVStruct.prevLenByteValue =
1891 NdefMap->SendRecvBuf[Temp16Bytes - 1];
1892 break;
1893 }
1894
1895
1896 ShiftLength =
1897 (uint16_t) (NdefMap->SendRecvBuf[Temp16Bytes]
1898 | (ShiftLength << PH_FRINFC_NDEFMAP_MFUL_SHIFT8));
1899
1900 // NdefMap->MifareULContainer.RemainingSize--;
1901
1902 if(ShiftLength > (NdefMap->MifareULContainer.RemainingSize))
1903 {
1904 // Size in the Length(L) of TLV is greater
1905 //than the actual size of the card
1906 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1907 NFCSTATUS_INVALID_PARAMETER);
1908 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1909 break;
1910 }
1911
1912 // NdefMap->MifareULContainer.RemainingSize--;
1913 /*
1914 NdefMap->TLVStruct.NdefTLVByte =
1915 (NdefMap->SendRecvBuf[Temp16Bytes] %
1916 PH_FRINFC_NDEFMAP_MFUL_VAL4);
1917
1918 NdefMap->TLVStruct.NdefTLVBlock =
1919 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock
1920 + (Temp16Bytes/PH_FRINFC_NDEFMAP_MFUL_VAL4));
1921 */
1922
1923 NdefMap->TLVStruct.ActualSize =
1924 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength;
1925
1926 NdefMap->TLVStruct.NdefTLVFoundFlag = 1;
1927
1928 NdefMap->TLVStruct.NdefTLVSector = NdefMap->MifareULContainer.CurrentSector;
1929
1930
1931 Result = ((NdefMap->TLVStruct.NoLbytesinTLV ==
1932 PH_FRINFC_NDEFMAP_MFUL_VAL0)?
1933 phFriNfc_MapTool_SetCardState( NdefMap, ShiftLength):
1934 Result);
1935 /*
1936 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
1937 NdefMap->TLVStruct.NdefTLVBlock);
1938 */
1939 break;
1940 }
1941 else
1942 {
1943 NdefMap->TLVStruct.BytesRemainLinTLV =
1944 NdefMap->SendRecvBuf[Temp16Bytes];
1945
1946 NdefMap->TLVStruct.ActualSize =
1947 NdefMap->SendRecvBuf[Temp16Bytes];
1948
1949 if((NdefMap->MifareULContainer.RemainingSize <
1950 NdefMap->SendRecvBuf[Temp16Bytes]) ||
1951 (NdefMap->MifareULContainer.RemainingSize <
1952 PH_FRINFC_NDEFMAP_MFUL_VAL2) ||
1953 (NdefMap->TLVStruct.BytesRemainLinTLV >
1954 (NdefMap->MifareULContainer.RemainingSize)) ||
1955 ((NdefMap->TLVStruct.BytesRemainLinTLV ==
1956 PH_FRINFC_NDEFMAP_MFUL_VAL0) &&
1957 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE)))
1958 {
1959 /* No NDEF TLV found */
1960 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1961 NFCSTATUS_NO_NDEF_SUPPORT);
1962 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1963 break;
1964 }
1965
1966 if(NdefMap->TLVStruct.NdefTLVFoundFlag !=
1967 PH_FRINFC_NDEFMAP_MFUL_FLAG1)
1968 {
1969 NdefMap->TLVStruct.NdefTLVByte =
1970 (((Temp16Bytes + PH_FRINFC_NDEFMAP_MFUL_VAL1 +
1971 NdefMap->SendRecvBuf[Temp16Bytes]) %
1972 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
1973 PH_FRINFC_NDEFMAP_MFUL_VAL1);
1974 NdefMap->TLVStruct.NdefTLVBlock =
1975 (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock
1976 + ((Temp16Bytes +
1977 NdefMap->SendRecvBuf[Temp16Bytes] + 1)/
1978 PH_FRINFC_NDEFMAP_MFUL_VAL4));
1979
1980 TemLength = (Temp16Bytes +
1981 NdefMap->SendRecvBuf[Temp16Bytes]);
1982
1983 NdefMap->MifareULContainer.RemainingSize =
1984 (NdefMap->MifareULContainer.RemainingSize -
1985 (NdefMap->SendRecvBuf[Temp16Bytes]
1986 + PH_FRINFC_NDEFMAP_MFUL_VAL1));
1987
1988 /* If the Length (L) in TLV < 16 bytes */
1989 Temp16Bytes = ((TemLength >=
1990 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
1991 PH_FRINFC_NDEFMAP_MFUL_VAL0:
1992 (TemLength +
1993 PH_FRINFC_NDEFMAP_MFUL_VAL1));
1994
1995 Result = ((TemLength >=
1996 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
1997 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
1998 NdefMap->TLVStruct.NdefTLVBlock):
1999 NFCSTATUS_SUCCESS);
2000
2001 if(TemLength >= PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
2002 {
2003 break;
2004 }
2005 TemLength = Temp16Bytes;
2006 }
2007 }
2008 if(NdefMap->TLVStruct.NdefTLVFoundFlag ==
2009 PH_FRINFC_NDEFMAP_MFUL_FLAG1)
2010 {
2011 #if 0
2012 NdefMap->TLVStruct.NdefTLVBlock =
2013 (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock
2014 + ((Temp16Bytes + 1)/
2015 PH_FRINFC_NDEFMAP_MFUL_VAL4)) - 1;
2016 #endif
2017 NdefMap->MifareULContainer.RemainingSize =
2018 (NdefMap->MifareULContainer.RemainingSize -
2019 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2020 ShiftLength = NdefMap->SendRecvBuf[Temp16Bytes];
2021 Result = ((NdefMap->TLVStruct.NoLbytesinTLV ==
2022 PH_FRINFC_NDEFMAP_MFUL_VAL0)?
2023 phFriNfc_MapTool_SetCardState( NdefMap, ShiftLength):
2024 Result);
2025
2026 break;
2027 }
2028 }
2029 }
2030 }
2031
2032 return Result;
2033 }
2034
2035
phFriNfc_MfUL_H_Chk16Bytes(phFriNfc_NdefMap_t * NdefMap,uint16_t TempLength)2036 static NFCSTATUS phFriNfc_MfUL_H_Chk16Bytes(phFriNfc_NdefMap_t *NdefMap,
2037 uint16_t TempLength)
2038 {
2039 uint16_t localCurrentBlock;
2040
2041 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2042 if(TempLength == PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
2043 {
2044 localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock +
2045 PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
2046
2047 if (localCurrentBlock < 256)
2048 {
2049 NdefMap->MifareULContainer.CurrentBlock +=
2050 PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
2051
2052 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
2053 NdefMap->MifareULContainer.CurrentBlock);
2054 }
2055 else
2056 {
2057 /* Go to next sector */
2058 NdefMap->MifareULContainer.CurrentSector++;
2059
2060 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
2061 NdefMap->MifareULContainer.CurrentSector, 1,
2062 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_1);
2063 }
2064 }
2065
2066 return Result;
2067 }
2068
2069
phFriNfc_MfUL_H_UpdateCrc(uint8_t ch,uint16_t * lpwCrc)2070 static void phFriNfc_MfUL_H_UpdateCrc( uint8_t ch,
2071 uint16_t *lpwCrc )
2072 {
2073 ch = (ch^(uint8_t)((*lpwCrc) & 0x00FF));
2074 ch = (ch^(ch<<4));
2075 *lpwCrc = (*lpwCrc >> 8)^((uint16_t)ch << 8)^ \
2076 ((uint16_t)ch<<3)^((uint16_t)ch>>4);
2077
2078 return;
2079 }
2080
phFriNfc_MfUL_H_ComputeCrc(int CRCType,uint8_t * Data,int Length,uint8_t * TransmitFirst,uint8_t * TransmitSecond)2081 static void phFriNfc_MfUL_H_ComputeCrc( int CRCType,
2082 uint8_t *Data,
2083 int Length,
2084 uint8_t *TransmitFirst,
2085 uint8_t *TransmitSecond
2086 )
2087 {
2088 uint8_t chBlock;
2089 uint16_t wCrc;
2090 switch(CRCType)
2091 {
2092 case CRC_A:
2093 wCrc = 0x6363; /* ITU-V.41 */
2094 break;
2095 case CRC_B:
2096 wCrc = 0xFFFF; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */
2097 break;
2098 default:
2099 return;
2100 }
2101
2102 do
2103 {
2104 chBlock = *Data++;
2105 phFriNfc_MfUL_H_UpdateCrc(chBlock, &wCrc);
2106 } while (--Length);
2107 *TransmitFirst = (uint8_t) (wCrc & 0xFF);
2108 *TransmitSecond = (uint8_t) ((wCrc >> 8) & 0xFF);
2109 return;
2110 }
2111
2112
2113
phFriNfc_MfUL_H_SelectSector(phFriNfc_NdefMap_t * NdefMap,uint8_t SectorNo,uint8_t CmdNo,uint8_t NextState)2114 static NFCSTATUS phFriNfc_MfUL_H_SelectSector(phFriNfc_NdefMap_t *NdefMap,
2115 uint8_t SectorNo,
2116 uint8_t CmdNo,
2117 uint8_t NextState)
2118 {
2119
2120 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2121
2122 /* set the data for additional data exchange */
2123 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2124 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2125 NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2126
2127 NdefMap->State = NextState;
2128
2129 if (CmdNo == 1)
2130 {
2131 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 0x00;
2132 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;
2133 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = 0xC2;
2134 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL3] = 0xFF;
2135 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL4;
2136 }
2137 else
2138 {
2139 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 0x00;
2140 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;
2141 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = SectorNo;
2142 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL3] = 0;
2143 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL4] = 0;
2144 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL5] = 0;
2145 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL5 + 1;
2146 }
2147
2148 /* Calculate CRC */
2149
2150 phFriNfc_MfUL_H_ComputeCrc(CRC_A, &NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2],
2151 NdefMap->SendLength - 2,
2152 &NdefMap->SendRecvBuf[NdefMap->SendLength],
2153 &NdefMap->SendRecvBuf[NdefMap->SendLength + 1]);
2154
2155 NdefMap->SendLength += PH_FRINFC_NDEFMAP_MFUL_VAL2;
2156
2157
2158 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
2159
2160 NdefMap->Cmd.MfCmd = phHal_eMifareRaw;
2161
2162 /* Call the overlapped HAL Transceive function */
2163 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice,
2164 &NdefMap->MapCompletionInfo,
2165 NdefMap->psRemoteDevInfo,
2166 NdefMap->Cmd,
2167 &NdefMap->psDepAdditionalInfo,
2168 NdefMap->SendRecvBuf,
2169 NdefMap->SendLength,
2170 NdefMap->SendRecvBuf,
2171 NdefMap->SendRecvLength);
2172 return Result;
2173 }
2174
2175
phFriNfc_MfUL_H_RdCardfindNdefTLV(phFriNfc_NdefMap_t * NdefMap,uint8_t BlockNo)2176 static NFCSTATUS phFriNfc_MfUL_H_RdCardfindNdefTLV( phFriNfc_NdefMap_t *NdefMap,
2177 uint8_t BlockNo)
2178 {
2179 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2180 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP;
2181 /* set the data for additional data exchange */
2182 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2183 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2184 NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2185 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] =
2186 BlockNo;
2187 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL1;
2188 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
2189
2190 /*
2191 * Changed
2192 * Description: phHal_eMifareCmdListMifareRead replace with phHal_eMifareRead
2193 */
2194 NdefMap->Cmd.MfCmd = phHal_eMifareRead;
2195
2196 /* Call the overlapped HAL Transceive function */
2197 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice,
2198 &NdefMap->MapCompletionInfo,
2199 NdefMap->psRemoteDevInfo,
2200 NdefMap->Cmd,
2201 &NdefMap->psDepAdditionalInfo,
2202 NdefMap->SendRecvBuf,
2203 NdefMap->SendLength,
2204 NdefMap->SendRecvBuf,
2205 NdefMap->SendRecvLength);
2206 return Result;
2207 }
2208
phFriNfc_MfUL_H_ChkRemainTLV(phFriNfc_NdefMap_t * NdefMap,uint8_t * CRFlag)2209 static NFCSTATUS phFriNfc_MfUL_H_ChkRemainTLV(phFriNfc_NdefMap_t *NdefMap,
2210 uint8_t *CRFlag)
2211 {
2212 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2213 uint16_t TempLength = PH_FRINFC_NDEFMAP_MFUL_VAL0,
2214 ShiftLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2215
2216 switch(NdefMap->TLVStruct.NoLbytesinTLV)
2217 {
2218 case PH_FRINFC_NDEFMAP_MFUL_VAL1:
2219 case PH_FRINFC_NDEFMAP_MFUL_VAL2:
2220 ShiftLength = ((NdefMap->TLVStruct.NoLbytesinTLV ==
2221 PH_FRINFC_NDEFMAP_MFUL_VAL1)?
2222 NdefMap->TLVStruct.prevLenByteValue:
2223 NdefMap->SendRecvBuf[TempLength]);
2224 ShiftLength = ((NdefMap->TLVStruct.NoLbytesinTLV ==
2225 PH_FRINFC_NDEFMAP_MFUL_VAL1)?
2226 (((uint16_t)(NdefMap->SendRecvBuf[TempLength]) <<
2227 PH_FRINFC_NDEFMAP_MFUL_SHIFT8) |
2228 ShiftLength):
2229 (((uint16_t)(NdefMap->SendRecvBuf[(TempLength +
2230 PH_FRINFC_NDEFMAP_MFUL_VAL1)]) <<
2231 PH_FRINFC_NDEFMAP_MFUL_SHIFT8) |
2232 ShiftLength));
2233
2234 NdefMap->MifareULContainer.RemainingSize -=
2235 PH_FRINFC_NDEFMAP_MFUL_VAL1;
2236
2237 NdefMap->TLVStruct.ActualSize =
2238 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength;
2239
2240 /* Check for remaining free space in the card with the
2241 length (L) of TLV OR length(L) of TLV is less than
2242 255 bytes (The length (L) of TLV for 3 byte should not
2243 be less than 255) */
2244 Result = ((((NdefMap->MifareULContainer.RemainingSize)<=
2245 ShiftLength) || (ShiftLength <
2246 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF))?
2247 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2248 NFCSTATUS_INVALID_PARAMETER)):
2249 Result);
2250
2251
2252 Result = ((Result == NFCSTATUS_SUCCESS)?
2253 phFriNfc_MapTool_SetCardState( NdefMap, ShiftLength):
2254 Result);
2255
2256 *CRFlag = (uint8_t)((Result == (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2257 NFCSTATUS_INVALID_PARAMETER)))?
2258 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
2259 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
2260
2261
2262 if(Result == NFCSTATUS_SUCCESS)
2263 {
2264
2265 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-
2266 NdefMap->TLVStruct.NoLbytesinTLV;
2267 /*
2268 NdefMap->TLVStruct.NdefTLVByte = ((ShiftLength%
2269 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
2270 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2271
2272 NdefMap->TLVStruct.NdefTLVBlock =
2273 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock
2274 + (ShiftLength/PH_FRINFC_NDEFMAP_MFUL_VAL4));
2275 NdefMap->MifareULContainer.CurrentBlock =
2276 NdefMap->TLVStruct.NdefTLVBlock;
2277
2278 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
2279 NdefMap->TLVStruct.NdefTLVBlock);
2280 */
2281 }
2282 break;
2283
2284 default:
2285 if((NdefMap->SendRecvBuf[TempLength] ==
2286 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) ||
2287 ((NdefMap->SendRecvBuf[TempLength] ==
2288 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) &&
2289 (NdefMap->TLVStruct.NdefTLVFoundFlag !=
2290 PH_FRINFC_NDEFMAP_MFUL_FLAG1)))
2291 {
2292 /* In the present case, the card space is not greater
2293 than 0xFF */
2294 /*
2295 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2296 NFCSTATUS_NO_NDEF_SUPPORT);
2297
2298 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
2299
2300 */
2301
2302 ShiftLength = NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_NDEFMAP_MFUL_VAL1)];
2303 ShiftLength = (((uint16_t)(NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_NDEFMAP_MFUL_VAL2)])
2304 << PH_FRINFC_NDEFMAP_MFUL_SHIFT8) |
2305 ShiftLength);
2306 Result = ((ShiftLength > (NdefMap->MifareULContainer.RemainingSize))?
2307 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2308 NFCSTATUS_INVALID_PARAMETER)):
2309 Result);
2310
2311
2312 Result = ((Result == NFCSTATUS_SUCCESS)?
2313 phFriNfc_MapTool_SetCardState( NdefMap, ShiftLength):
2314 Result);
2315
2316 NdefMap->TLVStruct.ActualSize =
2317 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength;
2318
2319 if(Result == NFCSTATUS_SUCCESS)
2320 {
2321
2322 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-
2323 NdefMap->TLVStruct.NoLbytesinTLV;
2324 /*
2325 NdefMap->TLVStruct.NdefTLVByte = ((ShiftLength%
2326 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
2327 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2328
2329 NdefMap->TLVStruct.NdefTLVBlock =
2330 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock
2331 + (ShiftLength/PH_FRINFC_NDEFMAP_MFUL_VAL4));
2332
2333 NdefMap->MifareULContainer.CurrentBlock =
2334 NdefMap->TLVStruct.NdefTLVBlock;
2335
2336 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
2337 NdefMap->TLVStruct.NdefTLVBlock);
2338 */
2339 }
2340 }
2341 else
2342 {
2343 /* length (L) value in TLV shall not be greater than
2344 remaining free space in the card */
2345 Result = ((NdefMap->SendRecvBuf[TempLength] >
2346 NdefMap->MifareULContainer.RemainingSize)?
2347 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2348 NFCSTATUS_INVALID_PARAMETER)):
2349 Result);
2350
2351 NdefMap->TLVStruct.ActualSize =
2352 NdefMap->TLVStruct.BytesRemainLinTLV =
2353 NdefMap->SendRecvBuf[TempLength];
2354 NdefMap->MifareULContainer.RemainingSize--;
2355
2356 if((Result == NFCSTATUS_SUCCESS) &&
2357 (NdefMap->TLVStruct.NdefTLVFoundFlag !=
2358 PH_FRINFC_NDEFMAP_MFUL_FLAG1))
2359 {
2360 phFriNfc_MfUL_H_UpdateLen(NdefMap,
2361 (uint16_t)NdefMap->SendRecvBuf[TempLength]);
2362
2363 NdefMap->MifareULContainer.CurrentBlock =
2364 NdefMap->TLVStruct.NdefTLVBlock;
2365 TempLength=TempLength+(NdefMap->SendRecvBuf[TempLength]);
2366 Result =((TempLength < PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
2367 phFriNfc_MfUL_H_findNDEFTLV(NdefMap, CRFlag):
2368 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
2369 NdefMap->TLVStruct.NdefTLVBlock));
2370 }
2371 }
2372 break;
2373 }
2374 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2375
2376 Result = phFriNfc_MapTool_SetCardState( NdefMap, NdefMap->TLVStruct.ActualSize);
2377
2378 return Result;
2379 }
2380
phFriNfc_MfUL_H_UpdateLen(phFriNfc_NdefMap_t * NdefMap,uint16_t DataLen)2381 static void phFriNfc_MfUL_H_UpdateLen(phFriNfc_NdefMap_t *NdefMap,
2382 uint16_t DataLen)
2383 {
2384 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-DataLen;
2385 NdefMap->TLVStruct.NdefTLVByte = ((DataLen %
2386 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
2387 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2388 NdefMap->TLVStruct.NdefTLVBlock =
2389 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock
2390 + (DataLen/PH_FRINFC_NDEFMAP_MFUL_VAL4));
2391 }
2392
phFriNfc_MfUL_H_NxtOp(phFriNfc_NdefMap_t * NdefMap,uint8_t * CRFlag)2393 static NFCSTATUS phFriNfc_MfUL_H_NxtOp(phFriNfc_NdefMap_t *NdefMap,
2394 uint8_t *CRFlag)
2395 {
2396 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2397
2398 switch(NdefMap->PrevOperation)
2399 {
2400 case PH_FRINFC_NDEFMAP_CHECK_OPE:
2401 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
2402 /* Fix to check if the actual size in the TLV is greater than card */
2403 if (NdefMap->TLVStruct.ActualSize > (NdefMap->CardMemSize - 2))
2404 {
2405 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2406 NFCSTATUS_NO_NDEF_SUPPORT);
2407 }
2408 break;
2409
2410 case PH_FRINFC_NDEFMAP_READ_OPE:
2411 if (NdefMap->TLVStruct.NdefTLVSector == 1)
2412 {
2413 /* Goto sector 1 */
2414 NdefMap->MifareULContainer.CurrentSector = 1;
2415 NdefMap->MifareULContainer.CurrentBlock = 0;
2416
2417 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
2418 NdefMap->MifareULContainer.CurrentSector, 1,
2419 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1);
2420 }
2421 else
2422 {
2423 NdefMap->MifareULContainer.CurrentBlock = (NdefMap->TLVStruct.NdefTLVBlock / 4) * 4;
2424
2425 Result = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);
2426 }
2427 #if 0
2428 NdefMap->MifareULContainer.CurrentBlock =
2429 PH_FRINFC_NDEFMAP_MFUL_VAL4;
2430
2431 Result = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);
2432 #endif
2433
2434
2435 *CRFlag = (uint8_t)((Result != NFCSTATUS_PENDING)?
2436 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
2437 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
2438 break;
2439
2440 case PH_FRINFC_NDEFMAP_WRITE_OPE:
2441 break;
2442
2443 default:
2444 break;
2445 }
2446 return Result;
2447 }
2448
2449
2450
phFriNfc_MfUL_H_CopyRdBytes(phFriNfc_NdefMap_t * NdefMap)2451 static NFCSTATUS phFriNfc_MfUL_H_CopyRdBytes(phFriNfc_NdefMap_t *NdefMap)
2452 {
2453 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2454 uint16_t localCurrentBlock;
2455
2456 #ifndef NDEF_READ_CHANGE
2457 uint16_t v_field_byte = 0;
2458
2459 if (NdefMap->MifareULContainer.CurrentBlock
2460 == NdefMap->TLVStruct.NdefTLVBlock)
2461 {
2462 if (NdefMap->CardMemSize > (0x12 * PH_FRINFC_NDEFMAP_MFUL_MUL8))
2463 {
2464 v_field_byte = NdefMap->TLVStruct.NdefTLVByte;
2465 }
2466
2467 /* Calculate the Value field of the TLV to read */
2468 if (NdefMap->TLVStruct.ActualSize >= 0xFF)
2469 {
2470
2471 /* here
2472 3 is the 3 LENGTH bytes to skip
2473 4 is the block size
2474 1 is to increment the byte number
2475 */
2476 v_field_byte = (uint16_t)
2477 (((v_field_byte + 3) % 4) + 1);
2478 }
2479 else
2480 {
2481 /* less than 0xFF */
2482 #if 0
2483 if ((0x03 == v_field_byte)
2484 || (0x04 == v_field_byte))
2485 {
2486 /*
2487 here
2488 1 is the 1 LENGTH byte to skip
2489 4 is the block size
2490 1 is to increment the byte number
2491 */
2492 v_field_byte = (uint16_t)
2493 (((v_field_byte + 1) % 4) + 1);
2494 }
2495 else
2496 {
2497 v_field_byte = (uint16_t)
2498 (v_field_byte + 1);
2499 }
2500 #endif /* #if 0 */
2501 }
2502 }
2503 #endif /* #ifndef NDEF_READ_CHANGE */
2504
2505 #ifndef NDEF_READ_CHANGE
2506 (void)memcpy(&(NdefMap->MifareULContainer.ReadBuf[
2507 NdefMap->MifareULContainer.ReadBufIndex]),
2508 (void *)(NdefMap->SendRecvBuf + v_field_byte),
2509 (*NdefMap->SendRecvLength - v_field_byte));
2510
2511 NdefMap->MifareULContainer.ReadBufIndex = (uint16_t)
2512 (NdefMap->MifareULContainer.ReadBufIndex +
2513 (*NdefMap->SendRecvLength - v_field_byte));
2514 #else /* #ifndef NDEF_READ_CHANGE */
2515
2516 (void)memcpy(&(NdefMap->MifareULContainer.ReadBuf[
2517 NdefMap->MifareULContainer.ReadBufIndex]),
2518 NdefMap->SendRecvBuf,
2519 *NdefMap->SendRecvLength);
2520
2521 NdefMap->MifareULContainer.ReadBufIndex=NdefMap->MifareULContainer.ReadBufIndex +*NdefMap->SendRecvLength;
2522 #endif /* #ifndef NDEF_READ_CHANGE */
2523
2524 localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock+
2525 (uint8_t)((NdefMap->MifareULContainer.ReadBufIndex !=
2526 NdefMap->CardMemSize)?
2527 PH_FRINFC_NDEFMAP_MFUL_BLOCK4:
2528 PH_FRINFC_NDEFMAP_MFUL_VAL0);
2529 if (localCurrentBlock < 256)
2530 {
2531 NdefMap->MifareULContainer.CurrentBlock = NdefMap->MifareULContainer.CurrentBlock+
2532 (uint8_t)((NdefMap->MifareULContainer.ReadBufIndex !=
2533 NdefMap->CardMemSize)?
2534 PH_FRINFC_NDEFMAP_MFUL_BLOCK4:
2535 PH_FRINFC_NDEFMAP_MFUL_VAL0);
2536 }
2537 else
2538 {
2539 /* Go to next sector */
2540 if (NdefMap->MifareULContainer.CurrentSector == 0)
2541 {
2542 NdefMap->MifareULContainer.CurrentSector++;
2543 NdefMap->MifareULContainer.CurrentBlock = 0xff;
2544
2545 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
2546 NdefMap->MifareULContainer.CurrentSector, 1,
2547 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1);
2548 }
2549 }
2550
2551 return Result;
2552 }
2553
phFriNfc_MfUL_H_CpDataToUserBuf(phFriNfc_NdefMap_t * NdefMap)2554 static NFCSTATUS phFriNfc_MfUL_H_CpDataToUserBuf(phFriNfc_NdefMap_t *NdefMap)
2555 {
2556 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2557
2558 /* Check the user buffer size with the
2559 L value of TLV */
2560 if(NdefMap->ApduBufferSize >=
2561 NdefMap->TLVStruct.BytesRemainLinTLV)
2562 {
2563 (void)memcpy(NdefMap->ApduBuffer,
2564 &(NdefMap->MifareULContainer.ReadBuf[
2565 NdefMap->MifareULContainer.ByteNumber]),
2566 NdefMap->TLVStruct.BytesRemainLinTLV);
2567
2568 *(NdefMap->NumOfBytesRead) =
2569 NdefMap->TLVStruct.BytesRemainLinTLV;
2570 NdefMap->MifareULContainer.ByteNumber =
2571 PH_FRINFC_NDEFMAP_MFUL_VAL0;
2572 NdefMap->MifareULContainer.ReadWriteCompleteFlag =
2573 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
2574 NdefMap->MifareULContainer.RemainingSize = NdefMap->MifareULContainer.RemainingSize-
2575 NdefMap->TLVStruct.BytesRemainLinTLV;
2576 NdefMap->TLVStruct.BytesRemainLinTLV =
2577 PH_FRINFC_NDEFMAP_MFUL_VAL0;
2578 }
2579 else
2580 {
2581 (void)memcpy(NdefMap->ApduBuffer,
2582 &(NdefMap->MifareULContainer.ReadBuf[
2583 NdefMap->MifareULContainer.ByteNumber]),
2584 NdefMap->ApduBufferSize);
2585
2586 *(NdefMap->NumOfBytesRead) =
2587 NdefMap->ApduBufferSize;
2588 NdefMap->MifareULContainer.ByteNumber = NdefMap->MifareULContainer.ByteNumber+
2589 (uint16_t)NdefMap->ApduBufferSize;
2590 NdefMap->MifareULContainer.RemainingSize=NdefMap->MifareULContainer.RemainingSize-
2591 (uint16_t)NdefMap->ApduBufferSize;
2592 NdefMap->TLVStruct.BytesRemainLinTLV = NdefMap->TLVStruct.BytesRemainLinTLV-
2593 (uint16_t)NdefMap->ApduBufferSize;
2594 }
2595 return Result;
2596 }
2597
phFriNfc_MfUL_H_RdBeforeWrite(phFriNfc_NdefMap_t * NdefMap)2598 static NFCSTATUS phFriNfc_MfUL_H_RdBeforeWrite(phFriNfc_NdefMap_t *NdefMap)
2599 {
2600 uint16_t localCurrentBlock = NdefMap->TLVStruct.NdefTLVBlock;
2601
2602 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2603 uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL0,
2604 i = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2605 /* BytesToWrite = PH_FRINFC_NDEFMAP_MFUL_VAL0;*/
2606 uint16_t TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2607
2608 switch((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1))
2609 {
2610 case PH_FRINFC_NDEFMAP_MFUL_VAL0:
2611 /* go the NDEF TLV block to start write */
2612 NdefMap->MifareULContainer.CurrentBlock =
2613 NdefMap->TLVStruct.NdefTLVBlock;
2614 /* fill send buffer for write */
2615 NdefMap->SendRecvBuf[index] =
2616 NdefMap->MifareULContainer.CurrentBlock;
2617 index++;
2618 NdefMap->SendRecvBuf[index] =
2619 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T;
2620 index++;
2621 if (NdefMap->ApduBufferSize > 254)
2622 {
2623 NdefMap->SendRecvBuf[index] = 0xFF;
2624 index++;
2625 NdefMap->SendRecvBuf[index] =
2626 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2627 index++;
2628 NdefMap->SendRecvBuf[index] =
2629 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2630 index++;
2631 }
2632 else
2633 {
2634 NdefMap->SendRecvBuf[index] =
2635 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2636 index++;
2637 }
2638
2639
2640 break;
2641
2642 case PH_FRINFC_NDEFMAP_MFUL_VAL1:
2643 case PH_FRINFC_NDEFMAP_MFUL_VAL2:
2644 /* read to get the previous bytes */
2645 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
2646 NdefMap->TLVStruct.NdefTLVBlock);
2647 break;
2648
2649 case PH_FRINFC_NDEFMAP_MFUL_VAL3:
2650
2651 localCurrentBlock = (NdefMap->MifareULContainer.CurrentBlock +
2652 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2653
2654 if (localCurrentBlock < 256)
2655 {
2656
2657 NdefMap->MifareULContainer.CurrentBlock =
2658 (NdefMap->MifareULContainer.CurrentBlock +
2659 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2660 NdefMap->SendRecvBuf[index] =
2661 NdefMap->MifareULContainer.CurrentBlock;
2662 index++;
2663
2664 if (NdefMap->ApduBufferSize > 254)
2665 {
2666 NdefMap->SendRecvBuf[index] = 0xFF;
2667 index++;
2668 NdefMap->SendRecvBuf[index] =
2669 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2670 index++;
2671 NdefMap->SendRecvBuf[index] =
2672 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2673 index++;
2674 }
2675 else
2676 {
2677 NdefMap->SendRecvBuf[index] =
2678 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2679 index++;
2680 }
2681 }
2682 else
2683 {
2684 /* Go to next sector */
2685 NdefMap->MifareULContainer.CurrentSector++;
2686
2687 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
2688 NdefMap->MifareULContainer.CurrentSector, 1,
2689 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_1);
2690 }
2691 break;
2692
2693 default:
2694 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2695 NFCSTATUS_INVALID_REMOTE_DEVICE);
2696 break;
2697 }
2698
2699 if((((NdefMap->TLVStruct.NdefTLVByte -
2700 PH_FRINFC_NDEFMAP_MFUL_VAL1) == PH_FRINFC_NDEFMAP_MFUL_VAL0) ||
2701 ((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1)
2702 == PH_FRINFC_NDEFMAP_MFUL_VAL3)) && localCurrentBlock < 256)
2703 {
2704 /* Length to know how many bytes has to be written to the card */
2705 TemLength = (((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) ==
2706 PH_FRINFC_NDEFMAP_MFUL_VAL0)?
2707 PH_FRINFC_NDEFMAP_MFUL_VAL2:
2708 PH_FRINFC_NDEFMAP_MFUL_VAL3);
2709
2710 if (NdefMap->ApduBufferSize > 254)
2711 {
2712 TemLength -= 2;
2713 }
2714
2715 if(NdefMap->ApduBufferSize >= TemLength)
2716 {
2717 /* Prepare the receive buffer */
2718 (void)memcpy(&(NdefMap->SendRecvBuf[
2719 index]),
2720 &(NdefMap->ApduBuffer[
2721 NdefMap->ApduBuffIndex]),
2722 TemLength);
2723
2724 /* Number of bytes written to the card from user buffer */
2725 NdefMap->NumOfBytesWritten = TemLength;
2726
2727 index = index+(uint8_t)TemLength;
2728 /* Exact number of bytes written in the card including TLV */
2729 if (index >= 1)
2730 {
2731 *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);
2732 }
2733 else
2734 {
2735 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2736 NFCSTATUS_INVALID_REMOTE_DEVICE);
2737 }
2738 }
2739 else
2740 {
2741 /* Prepare the receive buffer */
2742 (void)memcpy(&(NdefMap->SendRecvBuf[
2743 index]),
2744 &(NdefMap->ApduBuffer[
2745 NdefMap->ApduBuffIndex]),
2746 (uint16_t)NdefMap->ApduBufferSize);
2747
2748 /* Number of bytes written to the card from user buffer */
2749 NdefMap->NumOfBytesWritten = (uint16_t)NdefMap->ApduBufferSize;
2750
2751 index= index +(uint8_t)NdefMap->ApduBufferSize;
2752 /* Exact number of bytes written in the card including TLV */
2753 *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);
2754
2755 for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; i++)
2756 {
2757 NdefMap->SendRecvBuf[i] = (uint8_t)((i == index)?
2758 PH_FRINFC_NDEFMAP_MFUL_TERMTLV:
2759 PH_FRINFC_NDEFMAP_MFUL_NULLTLV);
2760 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
2761 }
2762 }
2763
2764 /* store the bytes in buffer till the bytes are
2765 written in a block */
2766 (void)memcpy(NdefMap->MifareULContainer.Buffer,
2767 &(NdefMap->SendRecvBuf[
2768 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
2769 (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK -
2770 PH_FRINFC_NDEFMAP_MFUL_VAL1));
2771
2772 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
2773 NdefMap->MifareULContainer.Buffer,
2774 (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK -
2775 PH_FRINFC_NDEFMAP_MFUL_VAL1));
2776
2777 /* Change the state to check ndef compliancy */
2778 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
2779
2780 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
2781 }
2782 return Result;
2783 }
2784
phFriNfc_MfUL_H_CallWrOp(phFriNfc_NdefMap_t * NdefMap)2785 static NFCSTATUS phFriNfc_MfUL_H_CallWrOp(phFriNfc_NdefMap_t *NdefMap)
2786 {
2787 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2788 /* uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL1;*/
2789
2790
2791 NdefMap->MifareULContainer.CurrentBlock =
2792 NdefMap->TLVStruct.NdefTLVBlock;
2793
2794 (void)memcpy(&(NdefMap->SendRecvBuf[
2795 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
2796 NdefMap->SendRecvBuf,
2797 PH_FRINFC_NDEFMAP_MFUL_VAL4);
2798
2799 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] =
2800 NdefMap->MifareULContainer.CurrentBlock;
2801
2802 if (NdefMap->ApduBufferSize > 254)
2803 {
2804 NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte +
2805 PH_FRINFC_NDEFMAP_MFUL_VAL1)] = 0xFF;
2806
2807
2808 if((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_NDEFMAP_MFUL_VAL1) <
2809 PH_FRINFC_NDEFMAP_MFUL_VAL4)
2810 {
2811 NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte +
2812 PH_FRINFC_NDEFMAP_MFUL_VAL2 )] = 0x00;
2813
2814 NdefMap->NumOfLReminWrite = 1;
2815
2816 }
2817 else
2818 {
2819 NdefMap->NumOfLReminWrite = 2;
2820 }
2821 NdefMap->NumOfBytesWritten = 0;
2822 }
2823 else
2824 {
2825 /* Write the length value = 0 */
2826 NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte +
2827 PH_FRINFC_NDEFMAP_MFUL_VAL1)] =
2828 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2829
2830 if((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_NDEFMAP_MFUL_VAL1) <
2831 PH_FRINFC_NDEFMAP_MFUL_VAL4)
2832 {
2833 /* Only one byte */
2834 (void)memcpy(&(NdefMap->SendRecvBuf[
2835 PH_FRINFC_NDEFMAP_MFUL_VAL4]),
2836 &(NdefMap->ApduBuffer[
2837 NdefMap->ApduBuffIndex]),
2838 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2839 /* Number of bytes written to the card from user buffer */
2840 NdefMap->NumOfBytesWritten = PH_FRINFC_NDEFMAP_MFUL_VAL1;
2841 }
2842 }
2843
2844 (void)memcpy(NdefMap->MifareULContainer.Buffer,
2845 &(NdefMap->SendRecvBuf[
2846 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
2847 PH_FRINFC_NDEFMAP_MFUL_VAL4);
2848
2849 /* Copy the Ndef TLV buffer to send buffer */
2850 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
2851 NdefMap->MifareULContainer.Buffer,
2852 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
2853
2854 /* Exact number of bytes written in the card including TLV */
2855 *NdefMap->DataCount = PH_FRINFC_NDEFMAP_MFUL_VAL4;
2856
2857 /* Change the state to check ndef compliancy */
2858 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
2859
2860 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
2861
2862 return Result;
2863 }
2864
phFriNfc_MfUL_H_ProWrittenBytes(phFriNfc_NdefMap_t * NdefMap)2865 static NFCSTATUS phFriNfc_MfUL_H_ProWrittenBytes(phFriNfc_NdefMap_t *NdefMap)
2866 {
2867 uint16_t localCurrentBlock;
2868 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2869 NFCSTATUS_INVALID_REMOTE_DEVICE);
2870
2871 if(NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize)
2872 {
2873 NdefMap->ApduBuffIndex = NdefMap->ApduBuffIndex+NdefMap->NumOfBytesWritten;
2874 if(*NdefMap->DataCount <
2875 PH_FRINFC_NDEFMAP_MFUL_VAL4)
2876 {
2877 (void)memcpy(NdefMap->MifareULContainer.InternalBuf,
2878 NdefMap->MifareULContainer.Buffer,
2879 *NdefMap->DataCount);
2880
2881 NdefMap->MifareULContainer.InternalLength = *NdefMap->DataCount;
2882 }
2883 else
2884 {
2885 NdefMap->MifareULContainer.InternalLength =
2886 PH_FRINFC_NDEFMAP_MFUL_VAL0;
2887 }
2888
2889 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-
2890 NdefMap->NumOfBytesWritten;
2891 if((NdefMap->ApduBuffIndex == NdefMap->ApduBufferSize) ||
2892 (NdefMap->MifareULContainer.RemainingSize ==
2893 PH_FRINFC_NDEFMAP_MFUL_VAL0))
2894 {
2895 Result = NFCSTATUS_SUCCESS;
2896 NdefMap->MifareULContainer.ReadWriteCompleteFlag =
2897 (uint8_t)((NdefMap->MifareULContainer.RemainingSize ==
2898 PH_FRINFC_NDEFMAP_MFUL_VAL0)?
2899 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
2900 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
2901
2902 NdefMap->TLVStruct.SetTermTLVFlag =
2903 (uint8_t)(((NdefMap->MifareULContainer.RemainingSize ==
2904 PH_FRINFC_NDEFMAP_MFUL_VAL0) ||
2905 (NdefMap->TLVStruct.SetTermTLVFlag ==
2906 PH_FRINFC_NDEFMAP_MFUL_FLAG1))?
2907 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
2908 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
2909
2910 NdefMap->MifareULContainer.CurrentBlock = NdefMap->MifareULContainer.CurrentBlock+
2911 (uint8_t)((NdefMap->MifareULContainer.InternalLength !=
2912 PH_FRINFC_NDEFMAP_MFUL_VAL0)?
2913 PH_FRINFC_NDEFMAP_MFUL_VAL0:
2914 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2915
2916 *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex;
2917 }
2918 else
2919 {
2920 localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock + 1;
2921 if (localCurrentBlock < 256)
2922 {
2923 NdefMap->MifareULContainer.CurrentBlock++;
2924 Result = phFriNfc_MfUL_H_fillSendBufToWr(NdefMap);
2925 }
2926 else
2927 {
2928 /* Go to next sector */
2929 NdefMap->MifareULContainer.CurrentSector++;
2930
2931 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
2932 NdefMap->MifareULContainer.CurrentSector, 1,
2933 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_1);
2934 }
2935 }
2936 }
2937
2938 if((Result == NFCSTATUS_SUCCESS) &&
2939 (NdefMap->TLVStruct.SetTermTLVFlag !=
2940 PH_FRINFC_NDEFMAP_MFUL_FLAG1) &&
2941 (NdefMap->MifareULContainer.RemainingSize >
2942 PH_FRINFC_NDEFMAP_MFUL_VAL0))
2943 {
2944 Result = phFriNfc_MfUL_H_WrTermTLV(NdefMap);
2945 }
2946 else
2947 {
2948 if((Result == NFCSTATUS_SUCCESS) &&
2949 (NdefMap->TLVStruct.SetTermTLVFlag ==
2950 PH_FRINFC_NDEFMAP_MFUL_FLAG1))
2951 {
2952 Result = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);
2953 }
2954 }
2955 return Result;
2956 }
phFriNfc_MfUL_H_fillSendBufToWr(phFriNfc_NdefMap_t * NdefMap)2957 static NFCSTATUS phFriNfc_MfUL_H_fillSendBufToWr(phFriNfc_NdefMap_t *NdefMap)
2958 {
2959 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2960 uint16_t RemainingBytes = PH_FRINFC_NDEFMAP_MFUL_VAL0,
2961 BytesToWrite = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2962 uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2963
2964 RemainingBytes = (uint16_t)(( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) <=
2965 NdefMap->MifareULContainer.RemainingSize)?
2966 (uint16_t)(NdefMap->ApduBufferSize -
2967 NdefMap->ApduBuffIndex):
2968 NdefMap->MifareULContainer.RemainingSize);
2969
2970 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] =
2971 NdefMap->MifareULContainer.CurrentBlock;
2972
2973 /* Get the number of bytes that can be written after copying
2974 the internal buffer */
2975 BytesToWrite = ((RemainingBytes <
2976 (PH_FRINFC_NDEFMAP_MFUL_BYTE4 -
2977 NdefMap->MifareULContainer.InternalLength))?
2978 RemainingBytes:
2979 (PH_FRINFC_NDEFMAP_MFUL_BYTE4 -
2980 NdefMap->MifareULContainer.InternalLength));
2981
2982 if (NdefMap->NumOfBytesWritten == 0 && NdefMap->NumOfLReminWrite > 0)
2983 {
2984 BytesToWrite = BytesToWrite - NdefMap->NumOfLReminWrite;
2985
2986 if (NdefMap->NumOfLReminWrite == 1)
2987 {
2988 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;
2989 }
2990 else
2991 {
2992 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;
2993 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = 0x00;
2994 }
2995 }
2996
2997 if(NdefMap->MifareULContainer.InternalLength >
2998 PH_FRINFC_NDEFMAP_MFUL_VAL0)
2999 {
3000 /* copy the internal buffer to the send buffer */
3001 (void)memcpy(&(NdefMap->SendRecvBuf[
3002 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
3003 NdefMap->MifareULContainer.InternalBuf,
3004 NdefMap->MifareULContainer.InternalLength);
3005
3006 }
3007
3008 /* Copy Bytes to write in the send buffer */
3009 (void)memcpy(&(NdefMap->SendRecvBuf[
3010 (PH_FRINFC_NDEFMAP_MFUL_VAL1 +
3011 NdefMap->MifareULContainer.InternalLength) +
3012 NdefMap->NumOfLReminWrite]),
3013 &(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]),
3014 BytesToWrite);
3015
3016 /* update number of bytes written from the user buffer */
3017 NdefMap->NumOfBytesWritten = BytesToWrite;
3018
3019 /* check the exact number of bytes written to a block including the
3020 internal length */
3021 *NdefMap->DataCount =
3022 (BytesToWrite + NdefMap->MifareULContainer.InternalLength +
3023 NdefMap->NumOfLReminWrite);
3024
3025
3026 /* if total bytes to write in the card is less than 4 bytes then
3027 pad zeroes till 4 bytes */
3028 if((BytesToWrite + NdefMap->MifareULContainer.InternalLength +
3029 NdefMap->NumOfLReminWrite)
3030 < PH_FRINFC_NDEFMAP_MFUL_BYTE4)
3031 {
3032 for(index = (uint8_t)((BytesToWrite + NdefMap->MifareULContainer.InternalLength + NdefMap->NumOfLReminWrite) +
3033 PH_FRINFC_NDEFMAP_MFUL_VAL1);
3034 index < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK;
3035 index++)
3036 {
3037 NdefMap->SendRecvBuf[index] = (uint8_t)((index ==
3038 ((BytesToWrite +
3039 NdefMap->MifareULContainer.InternalLength + NdefMap->NumOfLReminWrite) +
3040 PH_FRINFC_NDEFMAP_MFUL_VAL1))?
3041 PH_FRINFC_NDEFMAP_MFUL_TERMTLV:
3042 PH_FRINFC_NDEFMAP_MFUL_NULLTLV);
3043
3044 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
3045 }
3046 }
3047
3048 /* A temporary buffer to hold four bytes of data that is
3049 written to the card */
3050 (void)memcpy(NdefMap->MifareULContainer.Buffer,
3051 &(NdefMap->SendRecvBuf[
3052 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
3053 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3054
3055
3056
3057 if((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) <
3058 PH_FRINFC_NDEFMAP_MFUL_VAL3)
3059 {
3060 if ((NdefMap->TLVStruct.NdefTLVSector ==
3061 NdefMap->MifareULContainer.CurrentSector))
3062 {
3063 if(NdefMap->MifareULContainer.CurrentBlock ==
3064 NdefMap->TLVStruct.NdefTLVBlock)
3065 {
3066 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
3067 NdefMap->MifareULContainer.Buffer,
3068 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3069 }
3070 }
3071
3072 if ((NdefMap->TLVStruct.NdefTLVSector ==
3073 NdefMap->MifareULContainer.CurrentSector) ||
3074 (NdefMap->TLVStruct.NdefTLVBlock == 0xFF))
3075 {
3076 if(NdefMap->MifareULContainer.CurrentBlock ==
3077 (NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL1))
3078 {
3079 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer1,
3080 NdefMap->MifareULContainer.Buffer,
3081 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3082 }
3083 }
3084 }
3085 else
3086 {
3087 if ((NdefMap->TLVStruct.NdefTLVSector ==
3088 NdefMap->MifareULContainer.CurrentSector))
3089 {
3090 if(NdefMap->MifareULContainer.CurrentBlock ==
3091 (NdefMap->TLVStruct.NdefTLVBlock +
3092 PH_FRINFC_NDEFMAP_MFUL_VAL1))
3093 {
3094 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
3095 NdefMap->MifareULContainer.Buffer,
3096 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3097 }
3098 }
3099
3100 if ((NdefMap->TLVStruct.NdefTLVSector ==
3101 NdefMap->MifareULContainer.CurrentSector)||
3102 (NdefMap->TLVStruct.NdefTLVBlock == 0xFF))
3103 {
3104 if(NdefMap->MifareULContainer.CurrentBlock ==
3105 (NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL2))
3106 {
3107 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer1,
3108 NdefMap->MifareULContainer.Buffer,
3109 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3110 }
3111 }
3112 }
3113
3114
3115 /* Change the state to check ndef compliancy */
3116 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
3117
3118 NdefMap->NumOfLReminWrite = 0;
3119
3120 /* Start writing to the current block */
3121 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
3122
3123 return Result;
3124 }
phFriNfc_MfUL_H_WrTermTLV(phFriNfc_NdefMap_t * NdefMap)3125 static NFCSTATUS phFriNfc_MfUL_H_WrTermTLV(phFriNfc_NdefMap_t *NdefMap)
3126 {
3127 NFCSTATUS Result = NFCSTATUS_SUCCESS;
3128 uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL0,
3129 i = PH_FRINFC_NDEFMAP_MFUL_VAL0;
3130
3131 /* Change the state to check ndef compliancy */
3132 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV;
3133
3134 NdefMap->SendRecvBuf[index] =
3135 (NdefMap->MifareULContainer.CurrentBlock +
3136 PH_FRINFC_NDEFMAP_MFUL_VAL0);
3137 index++;
3138 NdefMap->SendRecvBuf[index] = PH_FRINFC_NDEFMAP_MFUL_TERMTLV;
3139 index++;
3140
3141 for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_VAL4; i++)
3142 {
3143 NdefMap->SendRecvBuf[i] = PH_FRINFC_NDEFMAP_MFUL_NULLTLV;
3144 }
3145
3146 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
3147 return Result;
3148 }
3149
phFriNfc_MfUL_H_UpdateWrLen(phFriNfc_NdefMap_t * NdefMap)3150 static NFCSTATUS phFriNfc_MfUL_H_UpdateWrLen(phFriNfc_NdefMap_t *NdefMap)
3151 {
3152 NFCSTATUS Result = NFCSTATUS_SUCCESS;
3153 uint16_t BlockNo = PH_FRINFC_NDEFMAP_MFUL_VAL0,
3154 ByteNo = PH_FRINFC_NDEFMAP_MFUL_VAL0;
3155
3156 if ((NdefMap->TLVStruct.NdefTLVSector ==
3157 NdefMap->MifareULContainer.CurrentSector) ||
3158 ((NdefMap->TLVStruct.NdefTLVBlock == 0xFF) &&
3159 (NdefMap->TLVStruct.NdefTLVByte == 4) &&
3160 (NdefMap->TLVStruct.NdefTLVSector == 0)))
3161 {
3162 BlockNo = (((NdefMap->TLVStruct.NdefTLVByte -
3163 PH_FRINFC_NDEFMAP_MFUL_VAL1) !=
3164 PH_FRINFC_NDEFMAP_MFUL_VAL3)?
3165 NdefMap->TLVStruct.NdefTLVBlock:
3166 (NdefMap->TLVStruct.NdefTLVBlock +
3167 PH_FRINFC_NDEFMAP_MFUL_VAL1));
3168
3169 ByteNo = (((NdefMap->TLVStruct.NdefTLVByte -
3170 PH_FRINFC_NDEFMAP_MFUL_VAL1) ==
3171 PH_FRINFC_NDEFMAP_MFUL_VAL3)?
3172 PH_FRINFC_NDEFMAP_MFUL_VAL1:
3173 (NdefMap->TLVStruct.NdefTLVByte +
3174 PH_FRINFC_NDEFMAP_MFUL_VAL1));
3175
3176 if (NdefMap->NumOfLReminWrite > 0)
3177 {
3178 BlockNo++;
3179
3180 /* Copy the Ndef TLV buffer to send buffer */
3181 (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1]),
3182 NdefMap->TLVStruct.NdefTLVBuffer1,
3183 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3184
3185 if (NdefMap->NumOfLReminWrite == 1)
3186 {
3187 /* NdefMap->SendRecvBuf[1] = (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8); */
3188 NdefMap->SendRecvBuf[1] = (uint8_t) NdefMap->ApduBuffIndex;
3189
3190 }
3191 else if (NdefMap->NumOfLReminWrite == 2)
3192 {
3193 NdefMap->SendRecvBuf[1] = (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8);
3194 NdefMap->SendRecvBuf[2]= (uint8_t) (NdefMap->ApduBuffIndex);
3195
3196 }
3197 else
3198 {
3199
3200 }
3201 NdefMap->NumOfLReminWrite = 0;
3202 }
3203 else
3204 {
3205 /* Copy the Ndef TLV buffer to send buffer */
3206 (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1]),
3207 NdefMap->TLVStruct.NdefTLVBuffer,
3208 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3209
3210
3211 if (NdefMap->ApduBuffIndex > 254)
3212 {
3213 ByteNo++;
3214 if ((ByteNo == 3) || (ByteNo == 2))
3215 {
3216 NdefMap->SendRecvBuf[ByteNo]= (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8);
3217 ByteNo++;
3218 NdefMap->SendRecvBuf[ByteNo] = (uint8_t) (NdefMap->ApduBuffIndex);
3219 ByteNo++;
3220 NdefMap->NumOfLReminWrite = 0;
3221 }
3222 else if (ByteNo == 4)
3223 {
3224 /* NdefMap->SendRecvBuf[ByteNo]= (uint8_t) (NdefMap->ApduBuffIndex); */
3225 NdefMap->SendRecvBuf[ByteNo]= (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8);
3226 ByteNo++;
3227 NdefMap->NumOfLReminWrite = 1;
3228 }
3229 else
3230 {
3231 NdefMap->NumOfLReminWrite = 2;
3232 }
3233 }
3234 else
3235 {
3236 NdefMap->SendRecvBuf[ByteNo]=
3237 (uint8_t)((NdefMap->Offset ==
3238 PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
3239 (uint8_t)NdefMap->ApduBuffIndex:
3240 (NdefMap->ApduBuffIndex +
3241 NdefMap->SendRecvBuf[ByteNo]));
3242 }
3243 }
3244
3245 (void)memcpy(NdefMap->MifareULContainer.Buffer,
3246 &(NdefMap->SendRecvBuf[
3247 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
3248 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3249
3250 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = (uint8_t)BlockNo;
3251 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
3252
3253 if (NdefMap->NumOfLReminWrite == 0)
3254 {
3255 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV;
3256 }
3257 else
3258 {
3259 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV;
3260 }
3261 }
3262 else if (NdefMap->TLVStruct.NdefTLVSector == 0)
3263 {
3264 /* Reset sector */
3265 NdefMap->MifareULContainer.CurrentSector = 0;
3266 NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
3267
3268 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
3269 NdefMap->MifareULContainer.CurrentSector, 1,
3270 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);
3271
3272 }
3273 else
3274 {
3275 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST);
3276 }
3277
3278
3279 return Result;
3280 }
3281 #ifdef UNIT_TEST
phFriNfc_MifareUL_UnitTest(void * Context,uint32_t Length)3282 extern void phFriNfc_MifareUL_UnitTest(void *Context,uint32_t Length)
3283 {
3284 uint8_t value=10;
3285 uint8_t* CrFlag=&value;
3286 phFriNfc_NdefMap_t *pNdefMap=(phFriNfc_NdefMap_t*)Context;
3287 phFriNfc_MfUL_H_UpdateLen(pNdefMap,(uint16_t) Length);
3288 phFriNfc_MfUL_H_WrTermTLV(pNdefMap);
3289 phFriNfc_MfUL_H_CallWrOp(pNdefMap);
3290 phFriNfc_MfUL_H_UpdateWrLen(pNdefMap);
3291 phFriNfc_MfUL_H_ChkRemainTLV(pNdefMap,CrFlag);
3292 phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap);
3293
3294 pNdefMap->PrevOperation=PH_FRINFC_NDEFMAP_READ_OPE;
3295 phFriNfc_MfUL_H_NxtOp(pNdefMap,CrFlag);
3296
3297 pNdefMap->PrevOperation=PH_FRINFC_NDEFMAP_WRITE_OPE;
3298 phFriNfc_MfUL_H_NxtOp(pNdefMap,CrFlag);
3299
3300 pNdefMap->TLVStruct.NoLbytesinTLV=PH_FRINFC_NDEFMAP_MFUL_VAL1;
3301 phFriNfc_MfUL_H_ChkRemainTLV(pNdefMap,CrFlag);
3302
3303 pNdefMap->SendRecvBuf[0x00]= PH_FRINFC_NDEFMAP_MFUL_NULLTLV;
3304 phFriNfc_MfUL_H_findNDEFTLV(pNdefMap,CrFlag);
3305
3306
3307 pNdefMap->SendRecvBuf[0x00]= PH_FRINFC_NDEFMAP_MFUL_NULLTLV;
3308 phFriNfc_MfUL_H_findNDEFTLV(pNdefMap,CrFlag);
3309
3310
3311 phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);
3312 pNdefMap->TLVStruct.NdefTLVByte=1;
3313 phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);
3314
3315 pNdefMap->TLVStruct.NdefTLVByte=3;
3316 phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);
3317
3318 pNdefMap->TLVStruct.NdefTLVByte=4;
3319 phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);
3320
3321
3322 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS);
3323 phFriNfc_MifareUL_H_Complete(NULL,NFCSTATUS_SUCCESS);
3324 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS);
3325 pNdefMap->State=PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
3326 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS);
3327
3328 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_FAILED);
3329 phFriNfc_MifareUL_H_Complete(NULL,NFCSTATUS_SUCCESS);
3330 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_FAILED);
3331
3332 *pNdefMap->DataCount=0x3;
3333 phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap);
3334
3335 pNdefMap->ApduBuffIndex=0x31;
3336 phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap);
3337
3338
3339
3340 }
3341
3342 #endif
3343 #endif /* PH_FRINFC_MAP_MIFAREUL_DISABLED */
3344
3345