Gitiles
Code Review Sign In
review.blissroms.org / platform_external_libnfc-nxp / refs/heads/o8.0-rebase / . / src / phFriNfc_MifareULMap.c
blob: efaaceb43cece3b93b6359504554b19066c7e09c [file] [log] [blame]
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 $
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]26 * $Revision: 1.36 $
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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 */
51static 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 */
58static 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 */
64static 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 */
71static 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 */
79static 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 */
86static 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 */
94static 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 */
101static 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 */
108static 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 */
114static 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 */
120static 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 */
126static 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 */
132static 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 */
138static 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 */
144static 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 */
150static 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 */
156static 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 */
162static 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 */
175static NFCSTATUS phFriNfc_MfUL_H_SelectSector(phFriNfc_NdefMap_t *NdefMap,
176 uint8_t SectorNo,
177 uint8_t CmdNo,
178 uint8_t NextState);
179
180
181
182static void phFriNfc_MfUL_H_UpdateCrc( uint8_t ch,
183 uint16_t *lpwCrc );
184
185static void phFriNfc_MfUL_H_ComputeCrc( int CRCType,
186 uint8_t *Data,
187 int Length,
188 uint8_t *TransmitFirst,
189 uint8_t *TransmitSecond
190 );
191
192static void
193phFriNfc_MfUL_CalcByteNum(phFriNfc_NdefMap_t *NdefMap);
194
195
196#define CRC_A 0
197#define CRC_B 1
198
199
200NFCSTATUS 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
257NFCSTATUS 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
333NFCSTATUS 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
431NFCSTATUS 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
507static void
508phFriNfc_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 {
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]524 TemLength = NdefMap->MifareULContainer.ReadBuf[i + 2] |
525 ((uint16_t)NdefMap->MifareULContainer.ReadBuf[i + 3] << 8);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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
551static
552void
553phFriNfc_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
579void 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 <
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]649 (NdefMap->TLVStruct.ActualSize + (((NdefMap->TLVStruct.NdefTLVBlock -
650 PH_FRINFC_NDEFMAP_MFUL_BLOCK4)
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]651 * PH_FRINFC_NDEFMAP_MFUL_VAL4) + (NdefMap->TLVStruct.NdefTLVByte - 1) + 4)))
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]652
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]653 {
654 Status = phFriNfc_MfUL_H_CopyRdBytes(NdefMap);
655 }
656
657 if (Status == NFCSTATUS_SUCCESS)
658 {
659 if(NdefMap->MifareULContainer.ReadBufIndex >=
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]660 (NdefMap->TLVStruct.ActualSize + (((NdefMap->TLVStruct.NdefTLVBlock -
661 PH_FRINFC_NDEFMAP_MFUL_BLOCK4)
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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
1288static 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
1420static 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
1439static 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
1481static 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
1515static 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] ==
Sunil Jogi3013fc72012-02-23 12:11:30 -0800[diff] [blame]1587 PH_FRINFC_NDEFMAP_MFUL_MEM_CTRL_TLV) ||
1588 (NdefMap->SendRecvBuf[Temp16Bytes] ==
1589 PH_FRINFC_NDEFMAP_MFUL_PROPRIETRY_TLV))
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1590 {
1591
1592 NdefMap->TLVStruct.NdefTLVByte =
1593 ((Temp16Bytes %
1594 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
1595 PH_FRINFC_NDEFMAP_MFUL_VAL1);
1596
1597 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1598 Temp16Bytes);
1599 if(Result != NFCSTATUS_SUCCESS)
1600 {
1601 NdefMap->TLVStruct.TcheckedinTLVFlag =
1602 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1603 NdefMap->TLVStruct.NoLbytesinTLV =
1604 PH_FRINFC_NDEFMAP_MFUL_VAL3;
1605 break;
1606 }
1607 Temp16Bytes++;
1608 NdefMap->MifareULContainer.RemainingSize -=
1609 PH_FRINFC_NDEFMAP_MFUL_VAL1;
1610
1611 if(NdefMap->MifareULContainer.RemainingSize ==
1612 PH_FRINFC_NDEFMAP_MFUL_VAL0)
1613 {
1614 Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1615 NFCSTATUS_NO_NDEF_SUPPORT));
1616 break;
1617 }
1618
1619 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1620 Temp16Bytes);
1621 if(Result != NFCSTATUS_SUCCESS)
1622 {
1623 NdefMap->TLVStruct.TcheckedinTLVFlag =
1624 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1625 NdefMap->TLVStruct.NoLbytesinTLV =
1626 PH_FRINFC_NDEFMAP_MFUL_VAL3;
1627 break;
1628 }
1629
1630
1631 /* If the value of the Length(L) in TLV is FF then enter else
1632 check for the card memory */
1633 if((NdefMap->SendRecvBuf[Temp16Bytes] ==
1634 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) ||
1635 ((NdefMap->SendRecvBuf[Temp16Bytes] ==
1636 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) &&
1637 (NdefMap->TLVStruct.NdefTLVFoundFlag !=
1638 PH_FRINFC_NDEFMAP_MFUL_FLAG1)))
1639 {
1640 /* In the present case, the card space is not greater
1641 than 0xFF */
1642 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1643 NFCSTATUS_NO_NDEF_SUPPORT);
1644
1645 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1646 break;
1647 }
1648 else
1649 {
1650 NdefMap->TLVStruct.BytesRemainLinTLV =
1651 NdefMap->SendRecvBuf[Temp16Bytes];
1652
1653 NdefMap->TLVStruct.ActualSize =
1654 NdefMap->SendRecvBuf[Temp16Bytes];
1655
1656 if((NdefMap->MifareULContainer.RemainingSize <
1657 NdefMap->SendRecvBuf[Temp16Bytes]) ||
1658 (NdefMap->MifareULContainer.RemainingSize <
1659 PH_FRINFC_NDEFMAP_MFUL_VAL2) ||
1660 (NdefMap->TLVStruct.BytesRemainLinTLV >
1661 (NdefMap->MifareULContainer.RemainingSize)) ||
1662 ((NdefMap->TLVStruct.BytesRemainLinTLV ==
1663 PH_FRINFC_NDEFMAP_MFUL_VAL0) &&
1664 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE)))
1665 {
1666 /* No NDEF TLV found */
1667 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1668 NFCSTATUS_NO_NDEF_SUPPORT);
1669 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1670 break;
1671 }
1672
1673 if(NdefMap->TLVStruct.NdefTLVFoundFlag !=
1674 PH_FRINFC_NDEFMAP_MFUL_FLAG1)
1675 {
1676 NdefMap->TLVStruct.NdefTLVByte =
1677 (((Temp16Bytes + PH_FRINFC_NDEFMAP_MFUL_VAL1 +
1678 NdefMap->SendRecvBuf[Temp16Bytes]) %
1679 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
1680 PH_FRINFC_NDEFMAP_MFUL_VAL1);
1681#if 0
1682 NdefMap->TLVStruct.NdefTLVBlock =
1683 (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock
1684 + ((Temp16Bytes +
1685 NdefMap->SendRecvBuf[Temp16Bytes] + 1)/
1686 PH_FRINFC_NDEFMAP_MFUL_VAL4));
1687#endif
1688 NdefMap->TLVStruct.NdefTLVBlock =
1689 (uint8_t)(((NdefMap->TLVStruct.NdefTLVBlock / PH_FRINFC_NDEFMAP_MFUL_VAL4) *
1690 PH_FRINFC_NDEFMAP_MFUL_VAL4)
1691 + ((Temp16Bytes + NdefMap->SendRecvBuf[Temp16Bytes] + 1)/
1692 PH_FRINFC_NDEFMAP_MFUL_VAL4));
1693
1694
1695 TemLength = (Temp16Bytes +
1696 NdefMap->SendRecvBuf[Temp16Bytes]);
1697
1698 NdefMap->MifareULContainer.RemainingSize =
1699 (NdefMap->MifareULContainer.RemainingSize -
1700 (NdefMap->SendRecvBuf[Temp16Bytes]
1701 + PH_FRINFC_NDEFMAP_MFUL_VAL1));
1702
1703 /* If the Length (L) in TLV < 16 bytes */
1704 Temp16Bytes = ((TemLength >=
1705 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
1706 PH_FRINFC_NDEFMAP_MFUL_VAL0:
1707 (TemLength +
1708 PH_FRINFC_NDEFMAP_MFUL_VAL1));
1709
1710 Result = ((TemLength >=
1711 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
1712 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
1713 NdefMap->TLVStruct.NdefTLVBlock):
1714 NFCSTATUS_SUCCESS);
1715
1716 if(TemLength >= PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
1717 {
1718 break;
1719 }
1720 TemLength = Temp16Bytes;
1721 }
1722 }
1723
1724
1725
1726
1727#if 0
1728
1729 NdefMap->MifareULContainer.RemainingSize =
1730 (NdefMap->MifareULContainer.RemainingSize -
1731 (NdefMap->SendRecvBuf[Temp16Bytes + 1]
1732 + PH_FRINFC_NDEFMAP_MFUL_VAL2));
1733
1734 NdefMap->TLVStruct.NdefTLVBlock =
1735 (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock
1736 + ((Temp16Bytes +
1737 NdefMap->SendRecvBuf[Temp16Bytes + 1] + 2)/
1738 PH_FRINFC_NDEFMAP_MFUL_VAL4));
1739
1740
1741 Temp16Bytes = Temp16Bytes +
1742 NdefMap->SendRecvBuf[Temp16Bytes + 1] + 2;
1743#endif
1744 }
1745#endif /* #ifdef PH_NDEF_MIFARE_ULC */
1746 else {
1747
1748 /* Check the byte for 0x03 Type of NDEF TLV */
1749 NdefMap->TLVStruct.NdefTLVFoundFlag =
1750 ((NdefMap->SendRecvBuf[Temp16Bytes] ==
1751 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T)?
1752 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
1753 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
1754
1755 if(NdefMap->TLVStruct.NdefTLVFoundFlag ==
1756 PH_FRINFC_NDEFMAP_MFUL_FLAG1)
1757 {
1758 ShiftLength = (Temp16Bytes +
1759 NdefMap->SendRecvBuf[Temp16Bytes]);
1760
1761 NdefMap->TLVStruct.NdefTLVByte =
1762 ((Temp16Bytes %
1763 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
1764 PH_FRINFC_NDEFMAP_MFUL_VAL1);
1765
1766 NdefMap->TLVStruct.NdefTLVBlock =
1767 (uint8_t)(((NdefMap->TLVStruct.NdefTLVBlock /4) * 4)
1768 + (Temp16Bytes)/
1769 PH_FRINFC_NDEFMAP_MFUL_VAL4);
1770
1771 NdefMap->TLVStruct.NdefTLVSector = NdefMap->MifareULContainer.CurrentSector;
1772
1773 }
1774#ifdef PH_HAL4_ENABLE
1775 else
1776 {
1777 /* if the Type of the NDEF TLV is not found, then return
1778 error saying no ndef TLV found*/
1779 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1780 NFCSTATUS_NO_NDEF_SUPPORT);
1781 break;
1782#if 0
1783 /* This change is added to continue the loop, if the Type of the
1784 NDEF TLV is not found
1785 16 bytes are read, so for each byte, there is a check for the
1786 Type (T) of the TLV, if T != 0x03, then increment the byte
1787 count and restart the loop, till the T = 0x03 is found or all
1788 the bytes in the card is completely read.
1789 */
1790 Temp16Bytes = (uint16_t)(Temp16Bytes + 1);
1791 NdefMap->MifareULContainer.RemainingSize -=
1792 PH_FRINFC_NDEFMAP_MFUL_VAL1;
1793 if (NdefMap->MifareULContainer.RemainingSize ==
1794 PH_FRINFC_NDEFMAP_MFUL_VAL0)
1795 {
1796 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1797 NFCSTATUS_NO_NDEF_SUPPORT);
1798 break;
1799 }
1800 else
1801 {
1802 Result = NFCSTATUS_SUCCESS;
1803 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1804 Temp16Bytes);
1805 if(NFCSTATUS_PENDING == Result)
1806 {
1807 break;
1808 }
1809 continue;
1810 }
1811#endif /* #if 0 */
1812 }
1813#endif /* #ifdef PH_HAL4_ENABLE */
1814
1815 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1816 Temp16Bytes);
1817 if(Result != NFCSTATUS_SUCCESS)
1818 {
1819 NdefMap->TLVStruct.TcheckedinTLVFlag =
1820 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1821 NdefMap->TLVStruct.NoLbytesinTLV =
1822 PH_FRINFC_NDEFMAP_MFUL_VAL3;
1823 break;
1824 }
1825 Temp16Bytes++;
1826 NdefMap->MifareULContainer.RemainingSize -=
1827 PH_FRINFC_NDEFMAP_MFUL_VAL1;
1828
1829 if(NdefMap->MifareULContainer.RemainingSize ==
1830 PH_FRINFC_NDEFMAP_MFUL_VAL0)
1831 {
1832 Result = (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1833 NFCSTATUS_NO_NDEF_SUPPORT));
1834 break;
1835 }
1836
1837 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1838 Temp16Bytes);
1839 if(Result != NFCSTATUS_SUCCESS)
1840 {
1841 NdefMap->TLVStruct.TcheckedinTLVFlag =
1842 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1843 NdefMap->TLVStruct.NoLbytesinTLV =
1844 PH_FRINFC_NDEFMAP_MFUL_VAL3;
1845 break;
1846 }
1847
1848 /* If the value of the Length(L) in TLV is FF then enter else
1849 check for the card memory */
1850 if((NdefMap->SendRecvBuf[Temp16Bytes] ==
1851 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) ||
1852 ((NdefMap->SendRecvBuf[Temp16Bytes] ==
1853 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) &&
1854 (NdefMap->TLVStruct.NdefTLVFoundFlag !=
1855 PH_FRINFC_NDEFMAP_MFUL_FLAG1)))
1856 {
1857 /* In the present case, the card space is not greater
1858 than 0xFF */
1859 /*
1860 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1861 NFCSTATUS_NO_NDEF_SUPPORT);
1862
1863 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1864 break;
1865 */
1866
1867 Temp16Bytes++;
1868 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1869 Temp16Bytes);
1870 if(Result != NFCSTATUS_SUCCESS)
1871 {
1872 NdefMap->TLVStruct.TcheckedinTLVFlag =
1873 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1874 NdefMap->TLVStruct.NoLbytesinTLV =
1875 PH_FRINFC_NDEFMAP_MFUL_VAL2;
1876
1877 break;
1878 }
1879
1880 ShiftLength = (uint16_t) NdefMap->SendRecvBuf[Temp16Bytes];
1881 NdefMap->MifareULContainer.RemainingSize--;
1882
1883 Temp16Bytes++;
1884 Result = phFriNfc_MfUL_H_Chk16Bytes(NdefMap,
1885 Temp16Bytes);
1886 if(Result != NFCSTATUS_SUCCESS)
1887 {
1888 NdefMap->TLVStruct.TcheckedinTLVFlag =
1889 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1890 NdefMap->TLVStruct.NoLbytesinTLV =
1891 PH_FRINFC_NDEFMAP_MFUL_VAL1;
1892 NdefMap->TLVStruct.prevLenByteValue =
1893 NdefMap->SendRecvBuf[Temp16Bytes - 1];
1894 break;
1895 }
1896
1897
1898 ShiftLength =
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]1899 (uint16_t) (NdefMap->SendRecvBuf[Temp16Bytes]
1900 | (ShiftLength << PH_FRINFC_NDEFMAP_MFUL_SHIFT8));
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1901
1902 // NdefMap->MifareULContainer.RemainingSize--;
1903
1904 if(ShiftLength > (NdefMap->MifareULContainer.RemainingSize))
1905 {
1906 // Size in the Length(L) of TLV is greater
1907 //than the actual size of the card
1908 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1909 NFCSTATUS_INVALID_PARAMETER);
1910 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1911 break;
1912 }
1913
1914 // NdefMap->MifareULContainer.RemainingSize--;
1915 /*
1916 NdefMap->TLVStruct.NdefTLVByte =
1917 (NdefMap->SendRecvBuf[Temp16Bytes] %
1918 PH_FRINFC_NDEFMAP_MFUL_VAL4);
1919
1920 NdefMap->TLVStruct.NdefTLVBlock =
1921 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock
1922 + (Temp16Bytes/PH_FRINFC_NDEFMAP_MFUL_VAL4));
1923 */
1924
1925 NdefMap->TLVStruct.ActualSize =
1926 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength;
1927
1928 NdefMap->TLVStruct.NdefTLVFoundFlag = 1;
1929
1930 NdefMap->TLVStruct.NdefTLVSector = NdefMap->MifareULContainer.CurrentSector;
1931
1932
1933 Result = ((NdefMap->TLVStruct.NoLbytesinTLV ==
1934 PH_FRINFC_NDEFMAP_MFUL_VAL0)?
1935 phFriNfc_MapTool_SetCardState( NdefMap, ShiftLength):
1936 Result);
1937/*
1938 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
1939 NdefMap->TLVStruct.NdefTLVBlock);
1940*/
1941 break;
1942 }
1943 else
1944 {
1945 NdefMap->TLVStruct.BytesRemainLinTLV =
1946 NdefMap->SendRecvBuf[Temp16Bytes];
1947
1948 NdefMap->TLVStruct.ActualSize =
1949 NdefMap->SendRecvBuf[Temp16Bytes];
1950
1951 if((NdefMap->MifareULContainer.RemainingSize <
1952 NdefMap->SendRecvBuf[Temp16Bytes]) ||
1953 (NdefMap->MifareULContainer.RemainingSize <
1954 PH_FRINFC_NDEFMAP_MFUL_VAL2) ||
1955 (NdefMap->TLVStruct.BytesRemainLinTLV >
1956 (NdefMap->MifareULContainer.RemainingSize)) ||
1957 ((NdefMap->TLVStruct.BytesRemainLinTLV ==
1958 PH_FRINFC_NDEFMAP_MFUL_VAL0) &&
1959 (NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE)))
1960 {
1961 /* No NDEF TLV found */
1962 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1963 NFCSTATUS_NO_NDEF_SUPPORT);
1964 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
1965 break;
1966 }
1967
1968 if(NdefMap->TLVStruct.NdefTLVFoundFlag !=
1969 PH_FRINFC_NDEFMAP_MFUL_FLAG1)
1970 {
1971 NdefMap->TLVStruct.NdefTLVByte =
1972 (((Temp16Bytes + PH_FRINFC_NDEFMAP_MFUL_VAL1 +
1973 NdefMap->SendRecvBuf[Temp16Bytes]) %
1974 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
1975 PH_FRINFC_NDEFMAP_MFUL_VAL1);
1976 NdefMap->TLVStruct.NdefTLVBlock =
1977 (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock
1978 + ((Temp16Bytes +
1979 NdefMap->SendRecvBuf[Temp16Bytes] + 1)/
1980 PH_FRINFC_NDEFMAP_MFUL_VAL4));
1981
1982 TemLength = (Temp16Bytes +
1983 NdefMap->SendRecvBuf[Temp16Bytes]);
1984
1985 NdefMap->MifareULContainer.RemainingSize =
1986 (NdefMap->MifareULContainer.RemainingSize -
1987 (NdefMap->SendRecvBuf[Temp16Bytes]
1988 + PH_FRINFC_NDEFMAP_MFUL_VAL1));
1989
1990 /* If the Length (L) in TLV < 16 bytes */
1991 Temp16Bytes = ((TemLength >=
1992 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
1993 PH_FRINFC_NDEFMAP_MFUL_VAL0:
1994 (TemLength +
1995 PH_FRINFC_NDEFMAP_MFUL_VAL1));
1996
1997 Result = ((TemLength >=
1998 PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
1999 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
2000 NdefMap->TLVStruct.NdefTLVBlock):
2001 NFCSTATUS_SUCCESS);
2002
2003 if(TemLength >= PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
2004 {
2005 break;
2006 }
2007 TemLength = Temp16Bytes;
2008 }
2009 }
2010 if(NdefMap->TLVStruct.NdefTLVFoundFlag ==
2011 PH_FRINFC_NDEFMAP_MFUL_FLAG1)
2012 {
2013#if 0
2014 NdefMap->TLVStruct.NdefTLVBlock =
2015 (uint8_t)(NdefMap->TLVStruct.NdefTLVBlock
2016 + ((Temp16Bytes + 1)/
2017 PH_FRINFC_NDEFMAP_MFUL_VAL4)) - 1;
2018#endif
2019 NdefMap->MifareULContainer.RemainingSize =
2020 (NdefMap->MifareULContainer.RemainingSize -
2021 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2022 ShiftLength = NdefMap->SendRecvBuf[Temp16Bytes];
2023 Result = ((NdefMap->TLVStruct.NoLbytesinTLV ==
2024 PH_FRINFC_NDEFMAP_MFUL_VAL0)?
2025 phFriNfc_MapTool_SetCardState( NdefMap, ShiftLength):
2026 Result);
2027
2028 break;
2029 }
2030 }
2031 }
2032 }
2033
2034 return Result;
2035}
2036
2037
2038static NFCSTATUS phFriNfc_MfUL_H_Chk16Bytes(phFriNfc_NdefMap_t *NdefMap,
2039 uint16_t TempLength)
2040{
2041 uint16_t localCurrentBlock;
2042
2043 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2044 if(TempLength == PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)
2045 {
2046 localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock +
2047 PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
2048
2049 if (localCurrentBlock < 256)
2050 {
2051 NdefMap->MifareULContainer.CurrentBlock +=
2052 PH_FRINFC_NDEFMAP_MFUL_BLOCK4;
2053
2054 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
2055 NdefMap->MifareULContainer.CurrentBlock);
2056 }
2057 else
2058 {
2059 /* Go to next sector */
2060 NdefMap->MifareULContainer.CurrentSector++;
2061
2062 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
2063 NdefMap->MifareULContainer.CurrentSector, 1,
2064 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_CHK_1);
2065 }
2066 }
2067
2068 return Result;
2069}
2070
2071
2072static void phFriNfc_MfUL_H_UpdateCrc( uint8_t ch,
2073 uint16_t *lpwCrc )
2074{
2075 ch = (ch^(uint8_t)((*lpwCrc) & 0x00FF));
2076 ch = (ch^(ch<<4));
2077 *lpwCrc = (*lpwCrc >> 8)^((uint16_t)ch << 8)^ \
2078 ((uint16_t)ch<<3)^((uint16_t)ch>>4);
2079
2080 return;
2081}
2082
2083static void phFriNfc_MfUL_H_ComputeCrc( int CRCType,
2084 uint8_t *Data,
2085 int Length,
2086 uint8_t *TransmitFirst,
2087 uint8_t *TransmitSecond
2088 )
2089{
2090 uint8_t chBlock;
2091 uint16_t wCrc;
2092 switch(CRCType)
2093 {
2094 case CRC_A:
2095 wCrc = 0x6363; /* ITU-V.41 */
2096 break;
2097 case CRC_B:
2098 wCrc = 0xFFFF; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */
2099 break;
2100 default:
2101 return;
2102 }
2103
2104 do
2105 {
2106 chBlock = *Data++;
2107 phFriNfc_MfUL_H_UpdateCrc(chBlock, &wCrc);
2108 } while (--Length);
2109 *TransmitFirst = (uint8_t) (wCrc & 0xFF);
2110 *TransmitSecond = (uint8_t) ((wCrc >> 8) & 0xFF);
2111 return;
2112}
2113
2114
2115
2116static NFCSTATUS phFriNfc_MfUL_H_SelectSector(phFriNfc_NdefMap_t *NdefMap,
2117 uint8_t SectorNo,
2118 uint8_t CmdNo,
2119 uint8_t NextState)
2120{
2121
2122 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2123
2124 /* set the data for additional data exchange */
2125 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2126 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2127 NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2128
2129 NdefMap->State = NextState;
2130
2131 if (CmdNo == 1)
2132 {
2133 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 0x00;
2134 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;
2135 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = 0xC2;
2136 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL3] = 0xFF;
2137 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL4;
2138 }
2139 else
2140 {
2141 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = 0x00;
2142 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;
2143 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = SectorNo;
2144 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL3] = 0;
2145 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL4] = 0;
2146 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL5] = 0;
2147 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL5 + 1;
2148 }
2149
2150 /* Calculate CRC */
2151
2152 phFriNfc_MfUL_H_ComputeCrc(CRC_A, &NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2],
2153 NdefMap->SendLength - 2,
2154 &NdefMap->SendRecvBuf[NdefMap->SendLength],
2155 &NdefMap->SendRecvBuf[NdefMap->SendLength + 1]);
2156
2157 NdefMap->SendLength += PH_FRINFC_NDEFMAP_MFUL_VAL2;
2158
2159
2160 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
2161
2162 NdefMap->Cmd.MfCmd = phHal_eMifareRaw;
2163
2164 /* Call the overlapped HAL Transceive function */
2165 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice,
2166 &NdefMap->MapCompletionInfo,
2167 NdefMap->psRemoteDevInfo,
2168 NdefMap->Cmd,
2169 &NdefMap->psDepAdditionalInfo,
2170 NdefMap->SendRecvBuf,
2171 NdefMap->SendLength,
2172 NdefMap->SendRecvBuf,
2173 NdefMap->SendRecvLength);
2174 return Result;
2175}
2176
2177
2178static NFCSTATUS phFriNfc_MfUL_H_RdCardfindNdefTLV( phFriNfc_NdefMap_t *NdefMap,
2179 uint8_t BlockNo)
2180{
2181 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2182 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_FND_NDEF_COMP;
2183 /* set the data for additional data exchange */
2184 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2185 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2186 NdefMap->psDepAdditionalInfo.NAD = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2187 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] =
2188 BlockNo;
2189 NdefMap->SendLength = PH_FRINFC_NDEFMAP_MFUL_VAL1;
2190 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
2191
2192 /*
2193 * Changed
2194 * Description: phHal_eMifareCmdListMifareRead replace with phHal_eMifareRead
2195 */
2196 NdefMap->Cmd.MfCmd = phHal_eMifareRead;
2197
2198 /* Call the overlapped HAL Transceive function */
2199 Result = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice,
2200 &NdefMap->MapCompletionInfo,
2201 NdefMap->psRemoteDevInfo,
2202 NdefMap->Cmd,
2203 &NdefMap->psDepAdditionalInfo,
2204 NdefMap->SendRecvBuf,
2205 NdefMap->SendLength,
2206 NdefMap->SendRecvBuf,
2207 NdefMap->SendRecvLength);
2208 return Result;
2209}
2210
2211static NFCSTATUS phFriNfc_MfUL_H_ChkRemainTLV(phFriNfc_NdefMap_t *NdefMap,
2212 uint8_t *CRFlag)
2213{
2214 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2215 uint16_t TempLength = PH_FRINFC_NDEFMAP_MFUL_VAL0,
2216 ShiftLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2217
2218 switch(NdefMap->TLVStruct.NoLbytesinTLV)
2219 {
2220 case PH_FRINFC_NDEFMAP_MFUL_VAL1:
2221 case PH_FRINFC_NDEFMAP_MFUL_VAL2:
2222 ShiftLength = ((NdefMap->TLVStruct.NoLbytesinTLV ==
2223 PH_FRINFC_NDEFMAP_MFUL_VAL1)?
2224 NdefMap->TLVStruct.prevLenByteValue:
2225 NdefMap->SendRecvBuf[TempLength]);
2226 ShiftLength = ((NdefMap->TLVStruct.NoLbytesinTLV ==
2227 PH_FRINFC_NDEFMAP_MFUL_VAL1)?
2228 (((uint16_t)(NdefMap->SendRecvBuf[TempLength]) <<
2229 PH_FRINFC_NDEFMAP_MFUL_SHIFT8) |
2230 ShiftLength):
2231 (((uint16_t)(NdefMap->SendRecvBuf[(TempLength +
2232 PH_FRINFC_NDEFMAP_MFUL_VAL1)]) <<
2233 PH_FRINFC_NDEFMAP_MFUL_SHIFT8) |
2234 ShiftLength));
2235
2236 NdefMap->MifareULContainer.RemainingSize -=
2237 PH_FRINFC_NDEFMAP_MFUL_VAL1;
2238
2239 NdefMap->TLVStruct.ActualSize =
2240 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength;
2241
2242 /* Check for remaining free space in the card with the
2243 length (L) of TLV OR length(L) of TLV is less than
2244 255 bytes (The length (L) of TLV for 3 byte should not
2245 be less than 255) */
2246 Result = ((((NdefMap->MifareULContainer.RemainingSize)<=
2247 ShiftLength) || (ShiftLength <
2248 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF))?
2249 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2250 NFCSTATUS_INVALID_PARAMETER)):
2251 Result);
2252
2253
2254 Result = ((Result == NFCSTATUS_SUCCESS)?
2255 phFriNfc_MapTool_SetCardState( NdefMap, ShiftLength):
2256 Result);
2257
2258 *CRFlag = (uint8_t)((Result == (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2259 NFCSTATUS_INVALID_PARAMETER)))?
2260 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
2261 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
2262
2263
2264 if(Result == NFCSTATUS_SUCCESS)
2265 {
2266
2267 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-
2268 NdefMap->TLVStruct.NoLbytesinTLV;
2269/*
2270 NdefMap->TLVStruct.NdefTLVByte = ((ShiftLength%
2271 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
2272 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2273
2274 NdefMap->TLVStruct.NdefTLVBlock =
2275 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock
2276 + (ShiftLength/PH_FRINFC_NDEFMAP_MFUL_VAL4));
2277 NdefMap->MifareULContainer.CurrentBlock =
2278 NdefMap->TLVStruct.NdefTLVBlock;
2279
2280 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
2281 NdefMap->TLVStruct.NdefTLVBlock);
2282 */
2283 }
2284 break;
2285
2286 default:
2287 if((NdefMap->SendRecvBuf[TempLength] ==
2288 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_LFF) ||
2289 ((NdefMap->SendRecvBuf[TempLength] ==
2290 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L) &&
2291 (NdefMap->TLVStruct.NdefTLVFoundFlag !=
2292 PH_FRINFC_NDEFMAP_MFUL_FLAG1)))
2293 {
2294 /* In the present case, the card space is not greater
2295 than 0xFF */
2296/*
2297 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2298 NFCSTATUS_NO_NDEF_SUPPORT);
2299
2300 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
2301
2302*/
2303
2304 ShiftLength = NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_NDEFMAP_MFUL_VAL1)];
2305 ShiftLength = (((uint16_t)(NdefMap->SendRecvBuf[(TempLength + PH_FRINFC_NDEFMAP_MFUL_VAL2)])
2306 << PH_FRINFC_NDEFMAP_MFUL_SHIFT8) |
2307 ShiftLength);
2308 Result = ((ShiftLength > (NdefMap->MifareULContainer.RemainingSize))?
2309 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2310 NFCSTATUS_INVALID_PARAMETER)):
2311 Result);
2312
2313
2314 Result = ((Result == NFCSTATUS_SUCCESS)?
2315 phFriNfc_MapTool_SetCardState( NdefMap, ShiftLength):
2316 Result);
2317
2318 NdefMap->TLVStruct.ActualSize =
2319 NdefMap->TLVStruct.BytesRemainLinTLV = ShiftLength;
2320
2321 if(Result == NFCSTATUS_SUCCESS)
2322 {
2323
2324 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-
2325 NdefMap->TLVStruct.NoLbytesinTLV;
2326/*
2327 NdefMap->TLVStruct.NdefTLVByte = ((ShiftLength%
2328 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
2329 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2330
2331 NdefMap->TLVStruct.NdefTLVBlock =
2332 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock
2333 + (ShiftLength/PH_FRINFC_NDEFMAP_MFUL_VAL4));
2334
2335 NdefMap->MifareULContainer.CurrentBlock =
2336 NdefMap->TLVStruct.NdefTLVBlock;
2337
2338 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
2339 NdefMap->TLVStruct.NdefTLVBlock);
2340*/
2341 }
2342 }
2343 else
2344 {
2345 /* length (L) value in TLV shall not be greater than
2346 remaining free space in the card */
2347 Result = ((NdefMap->SendRecvBuf[TempLength] >
2348 NdefMap->MifareULContainer.RemainingSize)?
2349 (PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2350 NFCSTATUS_INVALID_PARAMETER)):
2351 Result);
2352
2353 NdefMap->TLVStruct.ActualSize =
2354 NdefMap->TLVStruct.BytesRemainLinTLV =
2355 NdefMap->SendRecvBuf[TempLength];
2356 NdefMap->MifareULContainer.RemainingSize--;
2357
2358 if((Result == NFCSTATUS_SUCCESS) &&
2359 (NdefMap->TLVStruct.NdefTLVFoundFlag !=
2360 PH_FRINFC_NDEFMAP_MFUL_FLAG1))
2361 {
2362 phFriNfc_MfUL_H_UpdateLen(NdefMap,
2363 (uint16_t)NdefMap->SendRecvBuf[TempLength]);
2364
2365 NdefMap->MifareULContainer.CurrentBlock =
2366 NdefMap->TLVStruct.NdefTLVBlock;
2367 TempLength=TempLength+(NdefMap->SendRecvBuf[TempLength]);
2368 Result =((TempLength < PH_FRINFC_NDEFMAP_MFUL_RDBYTES_16)?
2369 phFriNfc_MfUL_H_findNDEFTLV(NdefMap, CRFlag):
2370 phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
2371 NdefMap->TLVStruct.NdefTLVBlock));
2372 }
2373 }
2374 break;
2375 }
2376 NdefMap->TLVStruct.NoLbytesinTLV = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2377
2378 Result = phFriNfc_MapTool_SetCardState( NdefMap, NdefMap->TLVStruct.ActualSize);
2379
2380 return Result;
2381}
2382
2383static void phFriNfc_MfUL_H_UpdateLen(phFriNfc_NdefMap_t *NdefMap,
2384 uint16_t DataLen)
2385{
2386 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-DataLen;
2387 NdefMap->TLVStruct.NdefTLVByte = ((DataLen %
2388 PH_FRINFC_NDEFMAP_MFUL_VAL4) +
2389 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2390 NdefMap->TLVStruct.NdefTLVBlock =
2391 (uint8_t)(NdefMap->MifareULContainer.CurrentBlock
2392 + (DataLen/PH_FRINFC_NDEFMAP_MFUL_VAL4));
2393}
2394
2395 static NFCSTATUS phFriNfc_MfUL_H_NxtOp(phFriNfc_NdefMap_t *NdefMap,
2396 uint8_t *CRFlag)
2397{
2398 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2399
2400 switch(NdefMap->PrevOperation)
2401 {
2402 case PH_FRINFC_NDEFMAP_CHECK_OPE:
2403 *CRFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]2404 /* Fix to check if the actual size in the TLV is greater than card */
2405 if (NdefMap->TLVStruct.ActualSize > (NdefMap->CardMemSize - 2))
2406 {
2407 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2408 NFCSTATUS_NO_NDEF_SUPPORT);
2409 }
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2410 break;
2411
2412 case PH_FRINFC_NDEFMAP_READ_OPE:
2413 if (NdefMap->TLVStruct.NdefTLVSector == 1)
2414 {
2415 /* Goto sector 1 */
2416 NdefMap->MifareULContainer.CurrentSector = 1;
2417 NdefMap->MifareULContainer.CurrentBlock = 0;
2418
2419 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
2420 NdefMap->MifareULContainer.CurrentSector, 1,
2421 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1);
2422 }
2423 else
2424 {
2425 NdefMap->MifareULContainer.CurrentBlock = (NdefMap->TLVStruct.NdefTLVBlock / 4) * 4;
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]2426
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2427 Result = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);
2428 }
2429#if 0
2430 NdefMap->MifareULContainer.CurrentBlock =
2431 PH_FRINFC_NDEFMAP_MFUL_VAL4;
2432
2433 Result = phFriNfc_MfUL_H_Rd16Bytes(NdefMap);
2434#endif
2435
2436
2437 *CRFlag = (uint8_t)((Result != NFCSTATUS_PENDING)?
2438 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
2439 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
2440 break;
2441
2442 case PH_FRINFC_NDEFMAP_WRITE_OPE:
2443 break;
2444
2445 default:
2446 break;
2447 }
2448 return Result;
2449}
2450
2451
2452
2453static NFCSTATUS phFriNfc_MfUL_H_CopyRdBytes(phFriNfc_NdefMap_t *NdefMap)
2454{
2455 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2456 uint16_t localCurrentBlock;
2457
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]2458#ifndef NDEF_READ_CHANGE
2459 uint16_t v_field_byte = 0;
2460
2461 if (NdefMap->MifareULContainer.CurrentBlock
2462 == NdefMap->TLVStruct.NdefTLVBlock)
2463 {
Nick Pellya25e0172011-01-31 13:24:40 -0800[diff] [blame]2464 if (NdefMap->CardMemSize > (0x12 * PH_FRINFC_NDEFMAP_MFUL_MUL8))
2465 {
2466 v_field_byte = NdefMap->TLVStruct.NdefTLVByte;
2467 }
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]2468
2469 /* Calculate the Value field of the TLV to read */
2470 if (NdefMap->TLVStruct.ActualSize >= 0xFF)
2471 {
2472
2473 /* here
2474 3 is the 3 LENGTH bytes to skip
2475 4 is the block size
2476 1 is to increment the byte number
2477 */
2478 v_field_byte = (uint16_t)
2479 (((v_field_byte + 3) % 4) + 1);
2480 }
2481 else
2482 {
2483 /* less than 0xFF */
2484#if 0
2485 if ((0x03 == v_field_byte)
2486 || (0x04 == v_field_byte))
2487 {
2488 /*
2489 here
2490 1 is the 1 LENGTH byte to skip
2491 4 is the block size
2492 1 is to increment the byte number
2493 */
2494 v_field_byte = (uint16_t)
2495 (((v_field_byte + 1) % 4) + 1);
2496 }
2497 else
2498 {
2499 v_field_byte = (uint16_t)
2500 (v_field_byte + 1);
2501 }
2502#endif /* #if 0 */
2503 }
2504 }
2505#endif /* #ifndef NDEF_READ_CHANGE */
2506
2507#ifndef NDEF_READ_CHANGE
2508 (void)memcpy(&(NdefMap->MifareULContainer.ReadBuf[
2509 NdefMap->MifareULContainer.ReadBufIndex]),
2510 (void *)(NdefMap->SendRecvBuf + v_field_byte),
2511 (*NdefMap->SendRecvLength - v_field_byte));
2512
2513 NdefMap->MifareULContainer.ReadBufIndex = (uint16_t)
2514 (NdefMap->MifareULContainer.ReadBufIndex +
2515 (*NdefMap->SendRecvLength - v_field_byte));
2516#else /* #ifndef NDEF_READ_CHANGE */
2517
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2518 (void)memcpy(&(NdefMap->MifareULContainer.ReadBuf[
2519 NdefMap->MifareULContainer.ReadBufIndex]),
2520 NdefMap->SendRecvBuf,
2521 *NdefMap->SendRecvLength);
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]2522
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2523 NdefMap->MifareULContainer.ReadBufIndex=NdefMap->MifareULContainer.ReadBufIndex +*NdefMap->SendRecvLength;
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]2524#endif /* #ifndef NDEF_READ_CHANGE */
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2525
2526 localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock+
2527 (uint8_t)((NdefMap->MifareULContainer.ReadBufIndex !=
2528 NdefMap->CardMemSize)?
2529 PH_FRINFC_NDEFMAP_MFUL_BLOCK4:
2530 PH_FRINFC_NDEFMAP_MFUL_VAL0);
2531 if (localCurrentBlock < 256)
2532 {
2533 NdefMap->MifareULContainer.CurrentBlock = NdefMap->MifareULContainer.CurrentBlock+
2534 (uint8_t)((NdefMap->MifareULContainer.ReadBufIndex !=
2535 NdefMap->CardMemSize)?
2536 PH_FRINFC_NDEFMAP_MFUL_BLOCK4:
2537 PH_FRINFC_NDEFMAP_MFUL_VAL0);
2538 }
2539 else
2540 {
2541 /* Go to next sector */
2542 if (NdefMap->MifareULContainer.CurrentSector == 0)
2543 {
2544 NdefMap->MifareULContainer.CurrentSector++;
2545 NdefMap->MifareULContainer.CurrentBlock = 0xff;
2546
2547 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
2548 NdefMap->MifareULContainer.CurrentSector, 1,
2549 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_READ_1);
2550 }
2551 }
2552
2553 return Result;
2554}
2555
2556static NFCSTATUS phFriNfc_MfUL_H_CpDataToUserBuf(phFriNfc_NdefMap_t *NdefMap)
2557{
2558 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2559
2560 /* Check the user buffer size with the
2561 L value of TLV */
2562 if(NdefMap->ApduBufferSize >=
2563 NdefMap->TLVStruct.BytesRemainLinTLV)
2564 {
2565 (void)memcpy(NdefMap->ApduBuffer,
2566 &(NdefMap->MifareULContainer.ReadBuf[
2567 NdefMap->MifareULContainer.ByteNumber]),
2568 NdefMap->TLVStruct.BytesRemainLinTLV);
2569
2570 *(NdefMap->NumOfBytesRead) =
2571 NdefMap->TLVStruct.BytesRemainLinTLV;
2572 NdefMap->MifareULContainer.ByteNumber =
2573 PH_FRINFC_NDEFMAP_MFUL_VAL0;
2574 NdefMap->MifareULContainer.ReadWriteCompleteFlag =
2575 PH_FRINFC_NDEFMAP_MFUL_FLAG1;
2576 NdefMap->MifareULContainer.RemainingSize = NdefMap->MifareULContainer.RemainingSize-
2577 NdefMap->TLVStruct.BytesRemainLinTLV;
2578 NdefMap->TLVStruct.BytesRemainLinTLV =
2579 PH_FRINFC_NDEFMAP_MFUL_VAL0;
2580 }
2581 else
2582 {
2583 (void)memcpy(NdefMap->ApduBuffer,
2584 &(NdefMap->MifareULContainer.ReadBuf[
2585 NdefMap->MifareULContainer.ByteNumber]),
2586 NdefMap->ApduBufferSize);
2587
2588 *(NdefMap->NumOfBytesRead) =
2589 NdefMap->ApduBufferSize;
2590 NdefMap->MifareULContainer.ByteNumber = NdefMap->MifareULContainer.ByteNumber+
2591 (uint16_t)NdefMap->ApduBufferSize;
2592 NdefMap->MifareULContainer.RemainingSize=NdefMap->MifareULContainer.RemainingSize-
2593 (uint16_t)NdefMap->ApduBufferSize;
2594 NdefMap->TLVStruct.BytesRemainLinTLV = NdefMap->TLVStruct.BytesRemainLinTLV-
2595 (uint16_t)NdefMap->ApduBufferSize;
2596 }
2597 return Result;
2598}
2599
2600static NFCSTATUS phFriNfc_MfUL_H_RdBeforeWrite(phFriNfc_NdefMap_t *NdefMap)
2601{
2602 uint16_t localCurrentBlock = NdefMap->TLVStruct.NdefTLVBlock;
2603
2604 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2605 uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL0,
2606 i = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2607 /* BytesToWrite = PH_FRINFC_NDEFMAP_MFUL_VAL0;*/
2608 uint16_t TemLength = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2609
2610 switch((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1))
2611 {
2612 case PH_FRINFC_NDEFMAP_MFUL_VAL0:
2613 /* go the NDEF TLV block to start write */
2614 NdefMap->MifareULContainer.CurrentBlock =
2615 NdefMap->TLVStruct.NdefTLVBlock;
2616 /* fill send buffer for write */
2617 NdefMap->SendRecvBuf[index] =
2618 NdefMap->MifareULContainer.CurrentBlock;
2619 index++;
2620 NdefMap->SendRecvBuf[index] =
2621 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_T;
2622 index++;
2623 if (NdefMap->ApduBufferSize > 254)
2624 {
2625 NdefMap->SendRecvBuf[index] = 0xFF;
2626 index++;
2627 NdefMap->SendRecvBuf[index] =
2628 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2629 index++;
2630 NdefMap->SendRecvBuf[index] =
2631 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2632 index++;
2633 }
2634 else
2635 {
2636 NdefMap->SendRecvBuf[index] =
2637 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2638 index++;
2639 }
2640
2641
2642 break;
2643
2644 case PH_FRINFC_NDEFMAP_MFUL_VAL1:
2645 case PH_FRINFC_NDEFMAP_MFUL_VAL2:
2646 /* read to get the previous bytes */
2647 Result = phFriNfc_MfUL_H_RdCardfindNdefTLV(NdefMap,
2648 NdefMap->TLVStruct.NdefTLVBlock);
2649 break;
2650
2651 case PH_FRINFC_NDEFMAP_MFUL_VAL3:
2652
2653 localCurrentBlock = (NdefMap->MifareULContainer.CurrentBlock +
2654 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2655
2656 if (localCurrentBlock < 256)
2657 {
2658
2659 NdefMap->MifareULContainer.CurrentBlock =
2660 (NdefMap->MifareULContainer.CurrentBlock +
2661 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2662 NdefMap->SendRecvBuf[index] =
2663 NdefMap->MifareULContainer.CurrentBlock;
2664 index++;
2665
2666 if (NdefMap->ApduBufferSize > 254)
2667 {
2668 NdefMap->SendRecvBuf[index] = 0xFF;
2669 index++;
2670 NdefMap->SendRecvBuf[index] =
2671 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2672 index++;
2673 NdefMap->SendRecvBuf[index] =
2674 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2675 index++;
2676 }
2677 else
2678 {
2679 NdefMap->SendRecvBuf[index] =
2680 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2681 index++;
2682 }
2683 }
2684 else
2685 {
2686 /* Go to next sector */
2687 NdefMap->MifareULContainer.CurrentSector++;
2688
2689 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
2690 NdefMap->MifareULContainer.CurrentSector, 1,
2691 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RW_1);
2692 }
2693 break;
2694
2695 default:
2696 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2697 NFCSTATUS_INVALID_REMOTE_DEVICE);
2698 break;
2699 }
2700
2701 if((((NdefMap->TLVStruct.NdefTLVByte -
2702 PH_FRINFC_NDEFMAP_MFUL_VAL1) == PH_FRINFC_NDEFMAP_MFUL_VAL0) ||
2703 ((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1)
2704 == PH_FRINFC_NDEFMAP_MFUL_VAL3)) && localCurrentBlock < 256)
2705 {
2706 /* Length to know how many bytes has to be written to the card */
2707 TemLength = (((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) ==
2708 PH_FRINFC_NDEFMAP_MFUL_VAL0)?
2709 PH_FRINFC_NDEFMAP_MFUL_VAL2:
2710 PH_FRINFC_NDEFMAP_MFUL_VAL3);
2711
2712 if (NdefMap->ApduBufferSize > 254)
2713 {
2714 TemLength -= 2;
2715 }
2716
2717 if(NdefMap->ApduBufferSize >= TemLength)
2718 {
2719 /* Prepare the receive buffer */
2720 (void)memcpy(&(NdefMap->SendRecvBuf[
2721 index]),
2722 &(NdefMap->ApduBuffer[
2723 NdefMap->ApduBuffIndex]),
2724 TemLength);
2725
2726 /* Number of bytes written to the card from user buffer */
2727 NdefMap->NumOfBytesWritten = TemLength;
2728
2729 index = index+(uint8_t)TemLength;
2730 /* Exact number of bytes written in the card including TLV */
2731 if (index >= 1)
2732 {
2733 *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);
2734 }
2735 else
2736 {
2737 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2738 NFCSTATUS_INVALID_REMOTE_DEVICE);
2739 }
2740 }
2741 else
2742 {
2743 /* Prepare the receive buffer */
2744 (void)memcpy(&(NdefMap->SendRecvBuf[
2745 index]),
2746 &(NdefMap->ApduBuffer[
2747 NdefMap->ApduBuffIndex]),
2748 (uint16_t)NdefMap->ApduBufferSize);
2749
2750 /* Number of bytes written to the card from user buffer */
2751 NdefMap->NumOfBytesWritten = (uint16_t)NdefMap->ApduBufferSize;
2752
2753 index= index +(uint8_t)NdefMap->ApduBufferSize;
2754 /* Exact number of bytes written in the card including TLV */
2755 *NdefMap->DataCount = (index - PH_FRINFC_NDEFMAP_MFUL_VAL1);
2756
2757 for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK; i++)
2758 {
2759 NdefMap->SendRecvBuf[i] = (uint8_t)((i == index)?
2760 PH_FRINFC_NDEFMAP_MFUL_TERMTLV:
2761 PH_FRINFC_NDEFMAP_MFUL_NULLTLV);
2762 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
2763 }
2764 }
2765
2766 /* store the bytes in buffer till the bytes are
2767 written in a block */
2768 (void)memcpy(NdefMap->MifareULContainer.Buffer,
2769 &(NdefMap->SendRecvBuf[
2770 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
2771 (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK -
2772 PH_FRINFC_NDEFMAP_MFUL_VAL1));
2773
2774 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
2775 NdefMap->MifareULContainer.Buffer,
2776 (PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK -
2777 PH_FRINFC_NDEFMAP_MFUL_VAL1));
2778
2779 /* Change the state to check ndef compliancy */
2780 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
2781
2782 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
2783 }
2784 return Result;
2785}
2786
2787static NFCSTATUS phFriNfc_MfUL_H_CallWrOp(phFriNfc_NdefMap_t *NdefMap)
2788{
2789 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2790 /* uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL1;*/
2791
2792
2793 NdefMap->MifareULContainer.CurrentBlock =
2794 NdefMap->TLVStruct.NdefTLVBlock;
2795
2796 (void)memcpy(&(NdefMap->SendRecvBuf[
2797 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
2798 NdefMap->SendRecvBuf,
2799 PH_FRINFC_NDEFMAP_MFUL_VAL4);
2800
2801 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] =
2802 NdefMap->MifareULContainer.CurrentBlock;
2803
2804 if (NdefMap->ApduBufferSize > 254)
2805 {
2806 NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte +
2807 PH_FRINFC_NDEFMAP_MFUL_VAL1)] = 0xFF;
2808
2809
2810 if((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_NDEFMAP_MFUL_VAL1) <
2811 PH_FRINFC_NDEFMAP_MFUL_VAL4)
2812 {
2813 NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte +
2814 PH_FRINFC_NDEFMAP_MFUL_VAL2 )] = 0x00;
2815
2816 NdefMap->NumOfLReminWrite = 1;
2817
2818 }
2819 else
2820 {
2821 NdefMap->NumOfLReminWrite = 2;
2822 }
2823 NdefMap->NumOfBytesWritten = 0;
2824 }
2825 else
2826 {
2827 /* Write the length value = 0 */
2828 NdefMap->SendRecvBuf[(NdefMap->TLVStruct.NdefTLVByte +
2829 PH_FRINFC_NDEFMAP_MFUL_VAL1)] =
2830 PH_FRINFC_NDEFMAP_MFUL_NDEFTLV_L;
2831
2832 if((NdefMap->TLVStruct.NdefTLVByte + PH_FRINFC_NDEFMAP_MFUL_VAL1) <
2833 PH_FRINFC_NDEFMAP_MFUL_VAL4)
2834 {
2835 /* Only one byte */
2836 (void)memcpy(&(NdefMap->SendRecvBuf[
2837 PH_FRINFC_NDEFMAP_MFUL_VAL4]),
2838 &(NdefMap->ApduBuffer[
2839 NdefMap->ApduBuffIndex]),
2840 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2841 /* Number of bytes written to the card from user buffer */
2842 NdefMap->NumOfBytesWritten = PH_FRINFC_NDEFMAP_MFUL_VAL1;
2843 }
2844 }
2845
2846 (void)memcpy(NdefMap->MifareULContainer.Buffer,
2847 &(NdefMap->SendRecvBuf[
2848 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
2849 PH_FRINFC_NDEFMAP_MFUL_VAL4);
2850
2851 /* Copy the Ndef TLV buffer to send buffer */
2852 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
2853 NdefMap->MifareULContainer.Buffer,
2854 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
2855
2856 /* Exact number of bytes written in the card including TLV */
2857 *NdefMap->DataCount = PH_FRINFC_NDEFMAP_MFUL_VAL4;
2858
2859 /* Change the state to check ndef compliancy */
2860 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
2861
2862 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
2863
2864 return Result;
2865}
2866
2867static NFCSTATUS phFriNfc_MfUL_H_ProWrittenBytes(phFriNfc_NdefMap_t *NdefMap)
2868{
2869 uint16_t localCurrentBlock;
2870 NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2871 NFCSTATUS_INVALID_REMOTE_DEVICE);
2872
2873 if(NdefMap->ApduBuffIndex < NdefMap->ApduBufferSize)
2874 {
2875 NdefMap->ApduBuffIndex = NdefMap->ApduBuffIndex+NdefMap->NumOfBytesWritten;
2876 if(*NdefMap->DataCount <
2877 PH_FRINFC_NDEFMAP_MFUL_VAL4)
2878 {
2879 (void)memcpy(NdefMap->MifareULContainer.InternalBuf,
2880 NdefMap->MifareULContainer.Buffer,
2881 *NdefMap->DataCount);
2882
2883 NdefMap->MifareULContainer.InternalLength = *NdefMap->DataCount;
2884 }
2885 else
2886 {
2887 NdefMap->MifareULContainer.InternalLength =
2888 PH_FRINFC_NDEFMAP_MFUL_VAL0;
2889 }
2890
2891 NdefMap->MifareULContainer.RemainingSize= NdefMap->MifareULContainer.RemainingSize-
2892 NdefMap->NumOfBytesWritten;
2893 if((NdefMap->ApduBuffIndex == NdefMap->ApduBufferSize) ||
2894 (NdefMap->MifareULContainer.RemainingSize ==
2895 PH_FRINFC_NDEFMAP_MFUL_VAL0))
2896 {
2897 Result = NFCSTATUS_SUCCESS;
2898 NdefMap->MifareULContainer.ReadWriteCompleteFlag =
2899 (uint8_t)((NdefMap->MifareULContainer.RemainingSize ==
2900 PH_FRINFC_NDEFMAP_MFUL_VAL0)?
2901 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
2902 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
2903
2904 NdefMap->TLVStruct.SetTermTLVFlag =
2905 (uint8_t)(((NdefMap->MifareULContainer.RemainingSize ==
2906 PH_FRINFC_NDEFMAP_MFUL_VAL0) ||
2907 (NdefMap->TLVStruct.SetTermTLVFlag ==
2908 PH_FRINFC_NDEFMAP_MFUL_FLAG1))?
2909 PH_FRINFC_NDEFMAP_MFUL_FLAG1:
2910 PH_FRINFC_NDEFMAP_MFUL_FLAG0);
2911
2912 NdefMap->MifareULContainer.CurrentBlock = NdefMap->MifareULContainer.CurrentBlock+
2913 (uint8_t)((NdefMap->MifareULContainer.InternalLength !=
2914 PH_FRINFC_NDEFMAP_MFUL_VAL0)?
2915 PH_FRINFC_NDEFMAP_MFUL_VAL0:
2916 PH_FRINFC_NDEFMAP_MFUL_VAL1);
2917
2918 *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex;
2919 }
2920 else
2921 {
2922 localCurrentBlock = NdefMap->MifareULContainer.CurrentBlock + 1;
2923 if (localCurrentBlock < 256)
2924 {
2925 NdefMap->MifareULContainer.CurrentBlock++;
2926 Result = phFriNfc_MfUL_H_fillSendBufToWr(NdefMap);
2927 }
2928 else
2929 {
2930 /* Go to next sector */
2931 NdefMap->MifareULContainer.CurrentSector++;
2932
2933 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
2934 NdefMap->MifareULContainer.CurrentSector, 1,
2935 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_WRITE_1);
2936 }
2937 }
2938 }
2939
2940 if((Result == NFCSTATUS_SUCCESS) &&
2941 (NdefMap->TLVStruct.SetTermTLVFlag !=
2942 PH_FRINFC_NDEFMAP_MFUL_FLAG1) &&
2943 (NdefMap->MifareULContainer.RemainingSize >
2944 PH_FRINFC_NDEFMAP_MFUL_VAL0))
2945 {
2946 Result = phFriNfc_MfUL_H_WrTermTLV(NdefMap);
2947 }
2948 else
2949 {
2950 if((Result == NFCSTATUS_SUCCESS) &&
2951 (NdefMap->TLVStruct.SetTermTLVFlag ==
2952 PH_FRINFC_NDEFMAP_MFUL_FLAG1))
2953 {
2954 Result = phFriNfc_MfUL_H_UpdateWrLen(NdefMap);
2955 }
2956 }
2957 return Result;
2958}
2959static NFCSTATUS phFriNfc_MfUL_H_fillSendBufToWr(phFriNfc_NdefMap_t *NdefMap)
2960{
2961 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2962 uint16_t RemainingBytes = PH_FRINFC_NDEFMAP_MFUL_VAL0,
2963 BytesToWrite = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2964 uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL0;
2965
2966 RemainingBytes = (uint16_t)(( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) <=
2967 NdefMap->MifareULContainer.RemainingSize)?
2968 (uint16_t)(NdefMap->ApduBufferSize -
2969 NdefMap->ApduBuffIndex):
2970 NdefMap->MifareULContainer.RemainingSize);
2971
2972 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] =
2973 NdefMap->MifareULContainer.CurrentBlock;
2974
2975 /* Get the number of bytes that can be written after copying
2976 the internal buffer */
2977 BytesToWrite = ((RemainingBytes <
2978 (PH_FRINFC_NDEFMAP_MFUL_BYTE4 -
2979 NdefMap->MifareULContainer.InternalLength))?
2980 RemainingBytes:
2981 (PH_FRINFC_NDEFMAP_MFUL_BYTE4 -
2982 NdefMap->MifareULContainer.InternalLength));
2983
2984 if (NdefMap->NumOfBytesWritten == 0 && NdefMap->NumOfLReminWrite > 0)
2985 {
2986 BytesToWrite = BytesToWrite - NdefMap->NumOfLReminWrite;
2987
2988 if (NdefMap->NumOfLReminWrite == 1)
2989 {
2990 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;
2991 }
2992 else
2993 {
2994 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1] = 0x00;
2995 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL2] = 0x00;
2996 }
2997 }
2998
2999 if(NdefMap->MifareULContainer.InternalLength >
3000 PH_FRINFC_NDEFMAP_MFUL_VAL0)
3001 {
3002 /* copy the internal buffer to the send buffer */
3003 (void)memcpy(&(NdefMap->SendRecvBuf[
3004 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
3005 NdefMap->MifareULContainer.InternalBuf,
3006 NdefMap->MifareULContainer.InternalLength);
3007
3008 }
3009
3010 /* Copy Bytes to write in the send buffer */
3011 (void)memcpy(&(NdefMap->SendRecvBuf[
3012 (PH_FRINFC_NDEFMAP_MFUL_VAL1 +
3013 NdefMap->MifareULContainer.InternalLength) +
3014 NdefMap->NumOfLReminWrite]),
3015 &(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex]),
3016 BytesToWrite);
3017
3018 /* update number of bytes written from the user buffer */
3019 NdefMap->NumOfBytesWritten = BytesToWrite;
3020
3021 /* check the exact number of bytes written to a block including the
3022 internal length */
3023 *NdefMap->DataCount =
3024 (BytesToWrite + NdefMap->MifareULContainer.InternalLength +
3025 NdefMap->NumOfLReminWrite);
3026
3027
3028 /* if total bytes to write in the card is less than 4 bytes then
3029 pad zeroes till 4 bytes */
3030 if((BytesToWrite + NdefMap->MifareULContainer.InternalLength +
3031 NdefMap->NumOfLReminWrite)
3032 < PH_FRINFC_NDEFMAP_MFUL_BYTE4)
3033 {
3034 for(index = (uint8_t)((BytesToWrite + NdefMap->MifareULContainer.InternalLength + NdefMap->NumOfLReminWrite) +
3035 PH_FRINFC_NDEFMAP_MFUL_VAL1);
3036 index < PH_FRINFC_NDEFMAP_MFUL_WR_A_BLK;
3037 index++)
3038 {
3039 NdefMap->SendRecvBuf[index] = (uint8_t)((index ==
3040 ((BytesToWrite +
3041 NdefMap->MifareULContainer.InternalLength + NdefMap->NumOfLReminWrite) +
3042 PH_FRINFC_NDEFMAP_MFUL_VAL1))?
3043 PH_FRINFC_NDEFMAP_MFUL_TERMTLV:
3044 PH_FRINFC_NDEFMAP_MFUL_NULLTLV);
3045
3046 NdefMap->TLVStruct.SetTermTLVFlag = PH_FRINFC_NDEFMAP_MFUL_FLAG1;
3047 }
3048 }
3049
3050 /* A temporary buffer to hold four bytes of data that is
3051 written to the card */
3052 (void)memcpy(NdefMap->MifareULContainer.Buffer,
3053 &(NdefMap->SendRecvBuf[
3054 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
3055 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3056
3057
3058
3059 if((NdefMap->TLVStruct.NdefTLVByte - PH_FRINFC_NDEFMAP_MFUL_VAL1) <
3060 PH_FRINFC_NDEFMAP_MFUL_VAL3)
3061 {
3062 if ((NdefMap->TLVStruct.NdefTLVSector ==
3063 NdefMap->MifareULContainer.CurrentSector))
3064 {
3065 if(NdefMap->MifareULContainer.CurrentBlock ==
3066 NdefMap->TLVStruct.NdefTLVBlock)
3067 {
3068 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
3069 NdefMap->MifareULContainer.Buffer,
3070 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3071 }
3072 }
3073
3074 if ((NdefMap->TLVStruct.NdefTLVSector ==
3075 NdefMap->MifareULContainer.CurrentSector) ||
3076 (NdefMap->TLVStruct.NdefTLVBlock == 0xFF))
3077 {
3078 if(NdefMap->MifareULContainer.CurrentBlock ==
3079 (NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL1))
3080 {
3081 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer1,
3082 NdefMap->MifareULContainer.Buffer,
3083 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3084 }
3085 }
3086 }
3087 else
3088 {
3089 if ((NdefMap->TLVStruct.NdefTLVSector ==
3090 NdefMap->MifareULContainer.CurrentSector))
3091 {
3092 if(NdefMap->MifareULContainer.CurrentBlock ==
3093 (NdefMap->TLVStruct.NdefTLVBlock +
3094 PH_FRINFC_NDEFMAP_MFUL_VAL1))
3095 {
3096 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer,
3097 NdefMap->MifareULContainer.Buffer,
3098 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3099 }
3100 }
3101
3102 if ((NdefMap->TLVStruct.NdefTLVSector ==
3103 NdefMap->MifareULContainer.CurrentSector)||
3104 (NdefMap->TLVStruct.NdefTLVBlock == 0xFF))
3105 {
3106 if(NdefMap->MifareULContainer.CurrentBlock ==
3107 (NdefMap->TLVStruct.NdefTLVBlock + PH_FRINFC_NDEFMAP_MFUL_VAL2))
3108 {
3109 (void)memcpy(NdefMap->TLVStruct.NdefTLVBuffer1,
3110 NdefMap->MifareULContainer.Buffer,
3111 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3112 }
3113 }
3114 }
3115
3116
3117 /* Change the state to check ndef compliancy */
3118 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
3119
3120 NdefMap->NumOfLReminWrite = 0;
3121
3122 /* Start writing to the current block */
3123 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
3124
3125 return Result;
3126}
3127static NFCSTATUS phFriNfc_MfUL_H_WrTermTLV(phFriNfc_NdefMap_t *NdefMap)
3128{
3129 NFCSTATUS Result = NFCSTATUS_SUCCESS;
3130 uint8_t index = PH_FRINFC_NDEFMAP_MFUL_VAL0,
3131 i = PH_FRINFC_NDEFMAP_MFUL_VAL0;
3132
3133 /* Change the state to check ndef compliancy */
3134 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV;
3135
3136 NdefMap->SendRecvBuf[index] =
3137 (NdefMap->MifareULContainer.CurrentBlock +
3138 PH_FRINFC_NDEFMAP_MFUL_VAL0);
3139 index++;
3140 NdefMap->SendRecvBuf[index] = PH_FRINFC_NDEFMAP_MFUL_TERMTLV;
3141 index++;
3142
3143 for(i = index; i < PH_FRINFC_NDEFMAP_MFUL_VAL4; i++)
3144 {
3145 NdefMap->SendRecvBuf[i] = PH_FRINFC_NDEFMAP_MFUL_NULLTLV;
3146 }
3147
3148 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
3149 return Result;
3150}
3151
3152static NFCSTATUS phFriNfc_MfUL_H_UpdateWrLen(phFriNfc_NdefMap_t *NdefMap)
3153{
3154 NFCSTATUS Result = NFCSTATUS_SUCCESS;
3155 uint16_t BlockNo = PH_FRINFC_NDEFMAP_MFUL_VAL0,
3156 ByteNo = PH_FRINFC_NDEFMAP_MFUL_VAL0;
3157
3158 if ((NdefMap->TLVStruct.NdefTLVSector ==
3159 NdefMap->MifareULContainer.CurrentSector) ||
3160 ((NdefMap->TLVStruct.NdefTLVBlock == 0xFF) &&
3161 (NdefMap->TLVStruct.NdefTLVByte == 4) &&
3162 (NdefMap->TLVStruct.NdefTLVSector == 0)))
3163 {
3164 BlockNo = (((NdefMap->TLVStruct.NdefTLVByte -
3165 PH_FRINFC_NDEFMAP_MFUL_VAL1) !=
3166 PH_FRINFC_NDEFMAP_MFUL_VAL3)?
3167 NdefMap->TLVStruct.NdefTLVBlock:
3168 (NdefMap->TLVStruct.NdefTLVBlock +
3169 PH_FRINFC_NDEFMAP_MFUL_VAL1));
3170
3171 ByteNo = (((NdefMap->TLVStruct.NdefTLVByte -
3172 PH_FRINFC_NDEFMAP_MFUL_VAL1) ==
3173 PH_FRINFC_NDEFMAP_MFUL_VAL3)?
3174 PH_FRINFC_NDEFMAP_MFUL_VAL1:
3175 (NdefMap->TLVStruct.NdefTLVByte +
3176 PH_FRINFC_NDEFMAP_MFUL_VAL1));
3177
3178 if (NdefMap->NumOfLReminWrite > 0)
3179 {
3180 BlockNo++;
3181
3182 /* Copy the Ndef TLV buffer to send buffer */
3183 (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1]),
3184 NdefMap->TLVStruct.NdefTLVBuffer1,
3185 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3186
3187 if (NdefMap->NumOfLReminWrite == 1)
3188 {
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]3189 /* NdefMap->SendRecvBuf[1] = (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8); */
3190 NdefMap->SendRecvBuf[1] = (uint8_t) NdefMap->ApduBuffIndex;
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]3191
3192 }
3193 else if (NdefMap->NumOfLReminWrite == 2)
3194 {
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]3195 NdefMap->SendRecvBuf[1] = (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8);
3196 NdefMap->SendRecvBuf[2]= (uint8_t) (NdefMap->ApduBuffIndex);
3197
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]3198 }
3199 else
3200 {
3201
3202 }
3203 NdefMap->NumOfLReminWrite = 0;
3204 }
3205 else
3206 {
3207 /* Copy the Ndef TLV buffer to send buffer */
3208 (void)memcpy(&(NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL1]),
3209 NdefMap->TLVStruct.NdefTLVBuffer,
3210 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3211
3212
3213 if (NdefMap->ApduBuffIndex > 254)
3214 {
3215 ByteNo++;
3216 if ((ByteNo == 3) || (ByteNo == 2))
3217 {
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]3218 NdefMap->SendRecvBuf[ByteNo]= (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]3219 ByteNo++;
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]3220 NdefMap->SendRecvBuf[ByteNo] = (uint8_t) (NdefMap->ApduBuffIndex);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]3221 ByteNo++;
3222 NdefMap->NumOfLReminWrite = 0;
3223 }
3224 else if (ByteNo == 4)
3225 {
Martijn Coenen75d1d112011-01-20 15:51:39 +0100[diff] [blame]3226 /* NdefMap->SendRecvBuf[ByteNo]= (uint8_t) (NdefMap->ApduBuffIndex); */
3227 NdefMap->SendRecvBuf[ByteNo]= (uint8_t) ((NdefMap->ApduBuffIndex & 0xFF00) >> 8);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]3228 ByteNo++;
3229 NdefMap->NumOfLReminWrite = 1;
3230 }
3231 else
3232 {
3233 NdefMap->NumOfLReminWrite = 2;
3234 }
3235 }
3236 else
3237 {
3238 NdefMap->SendRecvBuf[ByteNo]=
3239 (uint8_t)((NdefMap->Offset ==
3240 PH_FRINFC_NDEFMAP_SEEK_BEGIN)?
3241 (uint8_t)NdefMap->ApduBuffIndex:
3242 (NdefMap->ApduBuffIndex +
3243 NdefMap->SendRecvBuf[ByteNo]));
3244 }
3245 }
3246
3247 (void)memcpy(NdefMap->MifareULContainer.Buffer,
3248 &(NdefMap->SendRecvBuf[
3249 PH_FRINFC_NDEFMAP_MFUL_VAL1]),
3250 PH_FRINFC_NDEFMAP_MFUL_BYTE4);
3251
3252 NdefMap->SendRecvBuf[PH_FRINFC_NDEFMAP_MFUL_VAL0] = (uint8_t)BlockNo;
3253 Result = phFriNfc_MfUL_H_Wr4bytes(NdefMap);
3254
3255 if (NdefMap->NumOfLReminWrite == 0)
3256 {
3257 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_WR_LEN_TLV;
3258 }
3259 else
3260 {
3261 NdefMap->State = PH_FRINFC_NDEFMAP_MFUL_STATE_TERM_TLV;
3262 }
3263 }
3264 else if (NdefMap->TLVStruct.NdefTLVSector == 0)
3265 {
3266 /* Reset sector */
3267 NdefMap->MifareULContainer.CurrentSector = 0;
3268 NdefMap->PrevState = PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
3269
3270 Result = phFriNfc_MfUL_H_SelectSector(NdefMap,
3271 NdefMap->MifareULContainer.CurrentSector, 1,
3272 PH_FRINFC_NDEFMAP_MFUL_STATE_SELECT_SECTOR_RESET_1);
3273
3274 }
3275 else
3276 {
3277 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST);
3278 }
3279
3280
3281 return Result;
3282}
3283#ifdef UNIT_TEST
3284extern void phFriNfc_MifareUL_UnitTest(void *Context,uint32_t Length)
3285{
3286 uint8_t value=10;
3287 uint8_t* CrFlag=&value;
3288 phFriNfc_NdefMap_t *pNdefMap=(phFriNfc_NdefMap_t*)Context;
3289 phFriNfc_MfUL_H_UpdateLen(pNdefMap,(uint16_t) Length);
3290 phFriNfc_MfUL_H_WrTermTLV(pNdefMap);
3291 phFriNfc_MfUL_H_CallWrOp(pNdefMap);
3292 phFriNfc_MfUL_H_UpdateWrLen(pNdefMap);
3293 phFriNfc_MfUL_H_ChkRemainTLV(pNdefMap,CrFlag);
3294 phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap);
3295
3296 pNdefMap->PrevOperation=PH_FRINFC_NDEFMAP_READ_OPE;
3297 phFriNfc_MfUL_H_NxtOp(pNdefMap,CrFlag);
3298
3299 pNdefMap->PrevOperation=PH_FRINFC_NDEFMAP_WRITE_OPE;
3300 phFriNfc_MfUL_H_NxtOp(pNdefMap,CrFlag);
3301
3302 pNdefMap->TLVStruct.NoLbytesinTLV=PH_FRINFC_NDEFMAP_MFUL_VAL1;
3303 phFriNfc_MfUL_H_ChkRemainTLV(pNdefMap,CrFlag);
3304
3305 pNdefMap->SendRecvBuf[0x00]= PH_FRINFC_NDEFMAP_MFUL_NULLTLV;
3306 phFriNfc_MfUL_H_findNDEFTLV(pNdefMap,CrFlag);
3307
3308
3309 pNdefMap->SendRecvBuf[0x00]= PH_FRINFC_NDEFMAP_MFUL_NULLTLV;
3310 phFriNfc_MfUL_H_findNDEFTLV(pNdefMap,CrFlag);
3311
3312
3313 phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);
3314 pNdefMap->TLVStruct.NdefTLVByte=1;
3315 phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);
3316
3317 pNdefMap->TLVStruct.NdefTLVByte=3;
3318 phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);
3319
3320 pNdefMap->TLVStruct.NdefTLVByte=4;
3321 phFriNfc_MfUL_H_RdBeforeWrite(pNdefMap);
3322
3323
3324 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS);
3325 phFriNfc_MifareUL_H_Complete(NULL,NFCSTATUS_SUCCESS);
3326 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS);
3327 pNdefMap->State=PH_FRINFC_NDEFMAP_MFUL_STATE_WRITE;
3328 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_SUCCESS);
3329
3330 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_FAILED);
3331 phFriNfc_MifareUL_H_Complete(NULL,NFCSTATUS_SUCCESS);
3332 phFriNfc_MifareUL_H_Complete(pNdefMap,NFCSTATUS_FAILED);
3333
3334 *pNdefMap->DataCount=0x3;
3335 phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap);
3336
3337 pNdefMap->ApduBuffIndex=0x31;
3338 phFriNfc_MfUL_H_ProWrittenBytes(pNdefMap);
3339
3340
3341
3342}
3343
3344#endif
3345#endif /* PH_FRINFC_MAP_MIFAREUL_DISABLED */
3346