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_FelicaMap.c
19 * \brief This component encapsulates read/write/check ndef/process functionalities,
20 * for the Felica Smart Card.
21 *
22 * Project: NFC-FRI
23 *
24 * $Date: Thu May 6 14:01:35 2010 $
25 * $Author: ing07385 $
26 * $Revision: 1.10 $
27 * $Aliases: NFC_FRI1.1_WK1017_R34_4,NFC_FRI1.1_WK1023_R35_1 $
28 *
29 */
30
31 #ifndef PH_FRINFC_MAP_FELICA_DISABLED
32
33 #include <phNfcTypes.h>
34 #include <phFriNfc_OvrHal.h>
35 #include <phFriNfc_FelicaMap.h>
36 #include <phFriNfc_MapTools.h>
37
38
39 /*! \ingroup grp_file_attributes
40 * \name NDEF Mapping
41 *
42 * File: \ref phFriNfc_FelicaMap.c
43 *
44 */
45 /*@{*/
46
47 #define PHFRINFCNDEFMAP_FILEREVISION "$Revision: 1.10 $"
48 #define PHFRINFCNDEFMAP_FILEALIASES "$Aliases: NFC_FRI1.1_WK1017_R34_4,NFC_FRI1.1_WK1023_R35_1 $"
49
50 /*@}*/
51
52 /* Helpers for Read and updating the attribute informations*/
53 static NFCSTATUS phFriNfc_Felica_HRdAttrInfo(phFriNfc_NdefMap_t *NdefMap);
54 static NFCSTATUS phFriNfc_Felica_HUpdateAttrInfo(phFriNfc_NdefMap_t *NdefMap);
55 static NFCSTATUS phFriNfc_Felica_HCalCheckSum(const uint8_t *TempBuffer,
56 uint8_t StartIndex,
57 uint8_t EndIndex,
58 uint16_t RecvChkSum);
59
60 /* Helpers for Poll Related Operations*/
61 static NFCSTATUS phFriNfc_Felica_HPollCard( phFriNfc_NdefMap_t *NdefMap,
62 const uint8_t sysCode[],
63 uint8_t state);
64
65 static NFCSTATUS phFriNfc_Felica_HUpdateManufIdDetails(const phFriNfc_NdefMap_t *NdefMap);
66
67 /*Helpers for Reading Operations*/
68 static NFCSTATUS phFriNfc_Felica_HReadData(phFriNfc_NdefMap_t *NdefMap,uint8_t offset);
69 static uint16_t phFriNfc_Felica_HGetMaximumBlksToRead(const phFriNfc_NdefMap_t *NdefMap,uint8_t NbcOrNmaxb );
70 static void phFriNfc_Felica_HAfterRead_CopyDataToBuff(phFriNfc_NdefMap_t *NdefMap);
71 static NFCSTATUS phFriNfc_Felica_HSetTransceiveForRead(phFriNfc_NdefMap_t *NdefMap,uint16_t TrxLen,uint8_t Offset);
72 static uint16_t phFriNfc_Felica_HSetTrxLen(phFriNfc_NdefMap_t *NdefMap,uint16_t Nbc);
73 static NFCSTATUS phFriNfc_Felica_HChkApduBuff_Size( phFriNfc_NdefMap_t *NdefMap);
74
75 /* Helpers for Writing Operations*/
76 static NFCSTATUS phFriNfc_Felica_HChkAttrBlkForWrOp(phFriNfc_NdefMap_t *NdefMap);
77 static NFCSTATUS phFriNfc_Felica_HChkAttrBlkForRdOp(phFriNfc_NdefMap_t *NdefMap,
78 uint32_t NdefLen);
79 static NFCSTATUS phFriNfc_Felica_HUpdateAttrBlkForWrOp(phFriNfc_NdefMap_t *NdefMap,uint8_t isStarted);
80 static NFCSTATUS phFriNfc_Felica_HUpdateData(phFriNfc_NdefMap_t *NdefMap);
81 static NFCSTATUS phFriNfc_Felica_HWriteDataBlk(phFriNfc_NdefMap_t *NdefMap);
82
83 /* Write Empty NDEF Message*/
84 static NFCSTATUS phFriNfc_Felica_HWrEmptyMsg(phFriNfc_NdefMap_t *NdefMap);
85
86 /*Helpers for common checks*/
87 static NFCSTATUS phFriNfc_Felica_HCheckManufId(const phFriNfc_NdefMap_t *NdefMap);
88 static void phFriNfc_Felica_HCrHandler(phFriNfc_NdefMap_t *NdefMap,
89 uint8_t CrIndex,
90 NFCSTATUS Status);
91
92 static void phFriNfc_Felica_HInitInternalBuf(uint8_t *Buffer);
93
94 static int phFriNfc_Felica_MemCompare ( void *s1, void *s2, unsigned int n );
95
96 /*!
97 * \brief returns maximum number of blocks can be read from the Felica Smart Card.
98 *
99 * The function is useful in reading of NDEF information from a felica tag.
100 */
101
phFriNfc_Felica_HGetMaximumBlksToRead(const phFriNfc_NdefMap_t * NdefMap,uint8_t NbcOrNmaxb)102 static uint16_t phFriNfc_Felica_HGetMaximumBlksToRead(const phFriNfc_NdefMap_t *NdefMap, uint8_t NbcOrNmaxb )
103 {
104 uint16_t BlksToRead=0;
105 uint32_t DataLen = 0;
106 /* This part of the code is useful if we take account of Nbc blks reading*/
107 if ( NbcOrNmaxb == PH_NFCFRI_NDEFMAP_FELI_NBC )
108 {
109 PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0],
110 NdefMap->FelicaAttrInfo.LenBytes[1],
111 NdefMap->FelicaAttrInfo.LenBytes[2],
112 DataLen);
113 /* Calculate Nbc*/
114 BlksToRead = (uint16_t) ( ((DataLen % 16) == 0) ? (DataLen >> 4) : ((DataLen >> 4) +1) );
115
116
117 }
118 else if ( NbcOrNmaxb == PH_NFCFRI_NDEFMAP_FELI_NMAXB)
119 {
120 BlksToRead = NdefMap->FelicaAttrInfo.Nmaxb;
121 }
122 else
123 {
124 /* WARNING !!! code should not reach this point*/
125 ;
126 }
127 return (BlksToRead);
128 }
129
130 /*!
131 * \brief Initiates Reading of NDEF information from the Felica Card.
132 *
133 * The function initiates the reading of NDEF information from a Remote Device.
134 * It performs a reset of the state and starts the action (state machine).
135 * A periodic call of the \ref phFriNfcNdefMap_Process has to be
136 * done once the action has been triggered.
137 */
138
phFriNfc_Felica_RdNdef(phFriNfc_NdefMap_t * NdefMap,uint8_t * PacketData,uint32_t * PacketDataLength,uint8_t Offset)139 NFCSTATUS phFriNfc_Felica_RdNdef( phFriNfc_NdefMap_t *NdefMap,
140 uint8_t *PacketData,
141 uint32_t *PacketDataLength,
142 uint8_t Offset)
143 {
144
145 NFCSTATUS status = NFCSTATUS_PENDING;
146 uint32_t Nbc = 0;
147
148 NdefMap->ApduBufferSize = *PacketDataLength;
149 /*Store the packet data buffer*/
150 NdefMap->ApduBuffer = PacketData;
151
152 NdefMap->NumOfBytesRead = PacketDataLength ;
153 *NdefMap->NumOfBytesRead = 0;
154 NdefMap->ApduBuffIndex = 0;
155
156 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE;
157 NdefMap->Felica.Offset = Offset;
158
159 if( ( Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN )||( NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_WRITE_OPE))
160 {
161 NdefMap->Felica.CurBlockNo = 0;
162 NdefMap->Felica.OpFlag = PH_FRINFC_NDEFMAP_FELI_RD_ATTR_RD_OP;
163 NdefMap->Felica.IntermediateCpyFlag = FALSE;
164 NdefMap->Felica.IntermediateCpyLen = 0;
165 NdefMap->Felica.Rd_NoBytesToCopy = 0;
166 NdefMap->Felica.EofCardReachedFlag= FALSE ;
167 NdefMap->Felica.LastBlkReachedFlag = FALSE;
168 NdefMap->Felica.CurrBytesRead = 0;
169
170 phFriNfc_Felica_HInitInternalBuf(NdefMap->Felica.Rd_BytesToCopyBuff);
171
172 /* send request to read attribute information*/
173 status = phFriNfc_Felica_HRdAttrInfo(NdefMap);
174 /* handle the error in Transc function*/
175 if ( (status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
176 {
177 /* call respective CR */
178 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_CHK_NDEF,status);
179 }
180 }
181 else
182 {
183 Nbc = phFriNfc_Felica_HGetMaximumBlksToRead(NdefMap,PH_NFCFRI_NDEFMAP_FELI_NBC);
184
185 /* Offset = Current, but the read has reached the End of NBC Blocks */
186 if(( ( Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) && (NdefMap->Felica.CurBlockNo == Nbc)) &&
187 (NdefMap->Felica.EofCardReachedFlag == FELICA_RD_WR_EOF_CARD_REACHED ))
188 {
189 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
190 }
191 else
192 {
193
194 NdefMap->Felica.CurrBytesRead = ((NdefMap->Felica.CurBlockNo * 16)- NdefMap->Felica.Rd_NoBytesToCopy);
195 status = phFriNfc_Felica_HReadData(NdefMap,NdefMap->Felica.Offset);
196
197 }
198 }
199 return (status);
200 }
201
202 /*Read Operation Related Helper Routines*/
203
204 /*!
205 * \brief Used in Read Opearation.Sets the Trx Buffer Len calls Transc Cmd.
206 * After a successful read operation, function does checks the user buffer size
207 * sets the status flags.
208 */
209
phFriNfc_Felica_HReadData(phFriNfc_NdefMap_t * NdefMap,uint8_t offset)210 static NFCSTATUS phFriNfc_Felica_HReadData(phFriNfc_NdefMap_t *NdefMap,uint8_t offset)
211 {
212 NFCSTATUS status = NFCSTATUS_PENDING;
213 uint16_t Nbc=0,TranscLen=0;
214
215 Nbc = phFriNfc_Felica_HGetMaximumBlksToRead(NdefMap,PH_NFCFRI_NDEFMAP_FELI_NBC);
216 if( ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) > 0) && (NdefMap->Felica.CurBlockNo < Nbc ))
217 {
218 /* if data is present in the internal buffer*/
219 if (NdefMap->Felica.Rd_NoBytesToCopy > 0 )
220 {
221 /* copy data to external buffer*/
222 phFriNfc_Felica_HAfterRead_CopyDataToBuff(NdefMap);
223 /*Check the size of user buffer*/
224 status = phFriNfc_Felica_HChkApduBuff_Size(NdefMap);
225 if ( (status != NFCSTATUS_SUCCESS) && (NdefMap->Felica.IntermediateRdFlag == TRUE ))
226 {
227 /* set the transc len and call transc cmd*/
228 TranscLen = phFriNfc_Felica_HSetTrxLen(NdefMap,Nbc);
229 status= phFriNfc_Felica_HSetTransceiveForRead(NdefMap,TranscLen,offset);
230 }
231 else
232 {
233 /* Nothing to be done , if IntermediateRdFlag is set to zero*/
234 ;
235 }
236 }
237 else
238 {
239 /* set the transc len and call transc cmd*/
240 TranscLen = phFriNfc_Felica_HSetTrxLen(NdefMap,Nbc);
241 status= phFriNfc_Felica_HSetTransceiveForRead(NdefMap,TranscLen,offset);
242 }
243 }
244 else
245 {
246 /* Chk the Buffer size*/
247 status = phFriNfc_Felica_HChkApduBuff_Size(NdefMap);
248 if ( (status != NFCSTATUS_SUCCESS) && (NdefMap->Felica.IntermediateRdFlag == TRUE ))
249 {
250 TranscLen = phFriNfc_Felica_HSetTrxLen(NdefMap,Nbc);
251 status= phFriNfc_Felica_HSetTransceiveForRead(NdefMap,TranscLen,offset);
252 }
253 }
254 return (status);
255 }
256
257 /*!
258 * \brief Used in Read Opearation.Sets the Trx Buffer Len.
259 */
260
phFriNfc_Felica_HSetTrxLen(phFriNfc_NdefMap_t * NdefMap,uint16_t Nbc)261 static uint16_t phFriNfc_Felica_HSetTrxLen(phFriNfc_NdefMap_t *NdefMap,uint16_t Nbc)
262 {
263 uint16_t TranscLen = 0,BlocksToRead=0;
264
265 if( ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)% 16) == 0)
266 {
267 BlocksToRead = (uint16_t)( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)/16 );
268 }
269 else
270 {
271 BlocksToRead = (uint16_t)(((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)/16) +1);
272 }
273 if ( (BlocksToRead > Nbc) ||( (BlocksToRead) > ( Nbc - NdefMap->Felica.CurBlockNo)) )
274 {
275 BlocksToRead = Nbc - NdefMap->Felica.CurBlockNo;
276 }
277
278
279 if ( BlocksToRead >= NdefMap->FelicaAttrInfo.Nbr)
280 {
281 if( NdefMap->FelicaAttrInfo.Nbr < Nbc )
282 {
283 TranscLen = NdefMap->FelicaAttrInfo.Nbr*16;
284 }
285 else
286 {
287 TranscLen = Nbc*16;
288 NdefMap->Felica.LastBlkReachedFlag =1;
289 }
290 }
291 else
292 {
293 if (BlocksToRead <= Nbc )
294 {
295 if ( ( BlocksToRead * 16) == ((Nbc *16) - (NdefMap->Felica.CurBlockNo * 16)))
296 {
297 NdefMap->Felica.LastBlkReachedFlag =1;
298
299 }
300 TranscLen = BlocksToRead*16;
301
302 }
303 else
304 {
305 TranscLen = Nbc*16;
306 }
307 }
308 /* As Cur Blk changes, to remember the exact len what we had set
309 in the begining of each read operation*/
310 NdefMap->Felica.TrxLen = TranscLen;
311 return (TranscLen);
312 }
313
314 /*!
315 * \brief Used in Read Opearation.After a successful read operation,
316 * Copies the data to user buffer.
317 */
318
phFriNfc_Felica_HAfterRead_CopyDataToBuff(phFriNfc_NdefMap_t * NdefMap)319 static void phFriNfc_Felica_HAfterRead_CopyDataToBuff(phFriNfc_NdefMap_t *NdefMap)
320 {
321 uint8_t ResetFlag = FALSE, ExtrBytesToCpy = FALSE;
322 uint16_t Nbc=0;
323 uint32_t DataLen=0;
324
325 Nbc = phFriNfc_Felica_HGetMaximumBlksToRead(NdefMap,PH_NFCFRI_NDEFMAP_FELI_NBC );
326
327 PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0],
328 NdefMap->FelicaAttrInfo.LenBytes[1],
329 NdefMap->FelicaAttrInfo.LenBytes[2],
330 DataLen);
331 /* Internal Buffer has some old read bytes to cpy to user buffer*/
332 if( NdefMap->Felica.Rd_NoBytesToCopy > 0 )
333 {
334 if ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) < NdefMap->Felica.Rd_NoBytesToCopy )
335 {
336 NdefMap->Felica.Rd_NoBytesToCopy -= (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
337
338 if (NdefMap->Felica.IntermediateCpyFlag == TRUE )
339 {
340 /*Copy data from the internal buffer to user buffer*/
341 (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
342 (&(NdefMap->Felica.Rd_BytesToCopyBuff[NdefMap->Felica.IntermediateCpyLen])),
343 (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex));
344
345
346
347 /* Store number of bytes copied frm internal buffer to User Buffer */
348 NdefMap->Felica.IntermediateCpyLen += (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
349 NdefMap->Felica.IntermediateCpyFlag = 1;
350
351 /* check do we reach len bytes any chance*/
352 PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0],
353 NdefMap->FelicaAttrInfo.LenBytes[1],
354 NdefMap->FelicaAttrInfo.LenBytes[2],
355 DataLen);
356 /* Internal buffer has zero bytes for copy operation*/
357 if ( NdefMap->Felica.Rd_NoBytesToCopy == 0)
358 {
359 NdefMap->Felica.EofCardReachedFlag =FELICA_RD_WR_EOF_CARD_REACHED;
360 }
361 }
362 else
363 {
364 /*Copy data from the internal buffer to apdu buffer*/
365 (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
366 NdefMap->Felica.Rd_BytesToCopyBuff,
367 (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex));
368 }
369 NdefMap->ApduBuffIndex += (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
370
371 }
372 else if ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) == NdefMap->Felica.Rd_NoBytesToCopy )
373 {
374 if ( NdefMap->Felica.IntermediateCpyFlag == TRUE )
375 {
376 /*Copy data internal buff to apdubuffer*/
377 (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
378 (&(NdefMap->Felica.Rd_BytesToCopyBuff[NdefMap->Felica.IntermediateCpyLen])),
379 NdefMap->Felica.Rd_NoBytesToCopy);
380 }
381 else
382 {
383 /*Copy data internal buff to apdubuffer*/
384 (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
385 NdefMap->Felica.Rd_BytesToCopyBuff,
386 NdefMap->Felica.Rd_NoBytesToCopy);
387 }
388
389 /*increment the index,internal buffer len*/
390 NdefMap->ApduBuffIndex += NdefMap->Felica.Rd_NoBytesToCopy;
391 NdefMap->Felica.Rd_NoBytesToCopy -= (uint8_t)(NdefMap->ApduBuffIndex);
392
393 /* To reset the parameters*/
394 ResetFlag = TRUE;
395 }
396 else
397 {
398 /* Extra Bytes to Copy from internal buffer to external buffer*/
399 if ( NdefMap->Felica.IntermediateCpyFlag == TRUE )
400 {
401 /*Copy data internal buff to apdubuffer*/
402 (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
403 (&(NdefMap->Felica.Rd_BytesToCopyBuff[NdefMap->Felica.IntermediateCpyLen])),
404 NdefMap->Felica.Rd_NoBytesToCopy);
405 }
406 else
407 {
408 /*Copy data internal buff to apdubuffer*/
409 (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
410 NdefMap->Felica.Rd_BytesToCopyBuff,
411 NdefMap->Felica.Rd_NoBytesToCopy);
412 }
413 /*increment the index*/
414 NdefMap->ApduBuffIndex += NdefMap->Felica.Rd_NoBytesToCopy;
415
416 /* To reset the parameters*/
417 ResetFlag = TRUE;
418 }
419 }/*End of Internal Buffer has some old read bytes to cpy to user buffer*/
420 else
421 {
422 /* check if last block is reached*/
423 if ( ((NdefMap->Felica.LastBlkReachedFlag == 1) && (( NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= 16)) )
424 {
425 /* greater than 16 but less than the data len size*/
426 if (( NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= DataLen)
427 {
428 NdefMap->Felica.CurrBytesRead = (uint16_t)((DataLen) - (NdefMap->Felica.CurrBytesRead +
429 NdefMap->ApduBuffIndex));
430
431 (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
432 (&(NdefMap->SendRecvBuf[13])),
433 NdefMap->Felica.CurrBytesRead);
434
435 NdefMap->ApduBuffIndex += NdefMap->Felica.CurrBytesRead;
436 if ( NdefMap->ApduBuffIndex == DataLen)
437 {
438 ResetFlag = TRUE;
439 }
440 }
441 else
442 {
443 /* need to check exact no. of bytes to copy to buffer*/
444 if( ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) <= NdefMap->Felica.TrxLen )||
445 ((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) <= DataLen ))
446 {
447
448 ExtrBytesToCpy = TRUE;
449 }
450 else
451 {
452 NdefMap->Felica.Rd_NoBytesToCopy = (uint8_t)(16-(( Nbc * 16) - (DataLen)));
453
454 if ( NdefMap->Felica.Rd_NoBytesToCopy > (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex))
455 {
456 /*Reduce already copied bytes from the internal buffer*/
457 NdefMap->Felica.Rd_NoBytesToCopy -= (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
458 ExtrBytesToCpy = TRUE;
459 }
460 else
461 {
462 ExtrBytesToCpy = FALSE;
463 }
464 }
465 if ( ExtrBytesToCpy == TRUE )
466 {
467 NdefMap->Felica.CurrBytesRead = (uint16_t)((DataLen)- (NdefMap->Felica.CurrBytesRead +
468 NdefMap->ApduBuffIndex));
469
470 if(NdefMap->Felica.CurrBytesRead <
471 (uint16_t)(NdefMap->ApduBufferSize -
472 NdefMap->ApduBuffIndex))
473 {
474 (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
475 (&(NdefMap->SendRecvBuf[13])),
476 NdefMap->Felica.CurrBytesRead);
477 }
478 else
479 {
480 (void)memcpy( (&( NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
481 (&( NdefMap->SendRecvBuf[13])),
482 (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex));
483 }
484
485 if ( NdefMap->Felica.LastBlkReachedFlag == 1 )
486 {
487 NdefMap->Felica.Rd_NoBytesToCopy =
488 (uint8_t)((NdefMap->Felica.CurrBytesRead >
489 (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex))?
490 (NdefMap->Felica.CurrBytesRead -
491 (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)):
492 0);
493
494 ResetFlag = ((NdefMap->Felica.Rd_NoBytesToCopy == 0)?TRUE:FALSE);
495
496 }
497 else
498 {
499 NdefMap->Felica.Rd_NoBytesToCopy = (uint8_t)( NdefMap->Felica.TrxLen - (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex));
500 }
501
502 /* Copy remained bytes back into internal buffer*/
503 (void)memcpy( NdefMap->Felica.Rd_BytesToCopyBuff,
504 (&(NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_RESP_HEADER_LEN+(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)])),
505 NdefMap->Felica.Rd_NoBytesToCopy);
506
507 /* set the intermediate flag : This flag remembers that there are still X no. bytes remained in
508 Internal Buffer Ex: User has given only one byte buffer,needs to cpy one byte at a time*/
509 NdefMap->Felica.IntermediateCpyFlag = TRUE;
510
511 NdefMap->ApduBuffIndex += ((NdefMap->Felica.CurrBytesRead <
512 (uint16_t)(NdefMap->ApduBufferSize -
513 NdefMap->ApduBuffIndex))?
514 NdefMap->Felica.CurrBytesRead:
515 (uint16_t)(NdefMap->ApduBufferSize -
516 NdefMap->ApduBuffIndex));
517 }
518 else
519 {
520 /*Copy data from the internal buffer to user buffer*/
521 (void)memcpy( (&( NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
522 (&( NdefMap->SendRecvBuf[13])),
523 NdefMap->Felica.Rd_NoBytesToCopy);
524
525 NdefMap->ApduBuffIndex += NdefMap->Felica.Rd_NoBytesToCopy;
526 ResetFlag = TRUE;
527
528 }
529 }
530
531 }
532 else
533 {
534 if ((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) < NdefMap->Felica.TrxLen )
535 {
536 /* Calculate exactly remained bytes to copy to internal buffer and set it*/
537 if ( NdefMap->Felica.LastBlkReachedFlag == 1)
538 {
539 NdefMap->Felica.Rd_NoBytesToCopy = (uint8_t)(16-(( Nbc * 16) - DataLen));
540
541 if ( NdefMap->Felica.Rd_NoBytesToCopy > (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex))
542 {
543 /*Reduce already copied bytes from the internal buffer*/
544 NdefMap->Felica.Rd_NoBytesToCopy -= (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
545 ExtrBytesToCpy = TRUE;
546 }
547 }
548 else
549 {
550 NdefMap->Felica.Rd_NoBytesToCopy = (uint8_t)(NdefMap->Felica.TrxLen - (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex));
551 ExtrBytesToCpy = TRUE;
552 }
553 if ( ExtrBytesToCpy == TRUE )
554 {
555 /*Copy the read data from trx buffer to apdu of size apdu*/
556 (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
557 (&(NdefMap->SendRecvBuf[13])),
558 NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
559
560 /*copy bytesToCopy to internal buffer*/
561 (void)memcpy( NdefMap->Felica.Rd_BytesToCopyBuff,
562 (&(NdefMap->SendRecvBuf[13+(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)])),
563 NdefMap->Felica.Rd_NoBytesToCopy);
564
565 NdefMap->Felica.IntermediateCpyFlag = TRUE;
566 NdefMap->ApduBuffIndex += (uint16_t)NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex;
567 }
568 else
569 {
570 /*Copy data from the internal buffer to user buffer*/
571 (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
572 (&(NdefMap->SendRecvBuf[13])),
573 NdefMap->Felica.Rd_NoBytesToCopy);
574
575 NdefMap->ApduBuffIndex += NdefMap->Felica.Rd_NoBytesToCopy;
576 ResetFlag = TRUE;
577
578 }
579 if ( DataLen <= (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) )
580 {
581 NdefMap->Felica.EofCardReachedFlag =FELICA_RD_WR_EOF_CARD_REACHED;
582 }
583 else
584 {
585 ;
586 }
587 }
588 else if ((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) == NdefMap->Felica.TrxLen )
589 {
590 /*Copy exactly remained last bytes to user buffer and increment the index*/
591 /*13 : 1+12 : 1st byte entire pkt length + 12 bytes to skip manuf details*/
592 (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
593 (&(NdefMap->SendRecvBuf[13])),
594 (NdefMap->Felica.TrxLen ));
595
596 NdefMap->ApduBuffIndex += NdefMap->Felica.TrxLen;
597 }
598 else
599 {
600 if ((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) > NdefMap->Felica.TrxLen )
601 {
602 /*Copy the data to apdu buffer and increment the index */
603 (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
604 (&(NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_RESP_HEADER_LEN])),
605 NdefMap->Felica.TrxLen);
606
607 NdefMap->ApduBuffIndex += (uint16_t)NdefMap->Felica.TrxLen;
608 }
609 }
610 }
611 }
612 if ( ResetFlag == TRUE )
613 {
614 /* reset the internal buffer variables*/
615 NdefMap->Felica.Rd_NoBytesToCopy =0;
616 NdefMap->Felica.IntermediateCpyLen =0;
617 NdefMap->Felica.IntermediateCpyFlag =FALSE;
618 }
619 return;
620 }
621
622
623 /*!
624 * \brief Used in Read Opearation.After a successful read operation,
625 Checks the relavent buffer sizes and set the status.Following function is used
626 when we read the Nmaxb blocks. Retained for future purpose.
627 */
628
phFriNfc_Felica_HChkApduBuff_Size(phFriNfc_NdefMap_t * NdefMap)629 static NFCSTATUS phFriNfc_Felica_HChkApduBuff_Size( phFriNfc_NdefMap_t *NdefMap)
630 {
631 NFCSTATUS status = NFCSTATUS_PENDING;
632 uint8_t ResetFlag = FALSE;
633 uint32_t Nbc = 0;
634 uint32_t DataLen = 0;
635
636 Nbc = phFriNfc_Felica_HGetMaximumBlksToRead(NdefMap,PH_NFCFRI_NDEFMAP_FELI_NBC);
637
638 /* set status to Success : User Buffer is full and Curblk < nmaxb*/
639 if ( (( NdefMap->ApduBufferSize-NdefMap->ApduBuffIndex )== 0) &&
640 (NdefMap->Felica.CurBlockNo < Nbc ))
641 {
642 status = PHNFCSTVAL(CID_NFC_NONE,
643 NFCSTATUS_SUCCESS);
644 /*Reset the index, internal buffer counters back to zero*/
645 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex;
646 NdefMap->ApduBuffIndex = 0;
647
648 }/*if( (NdefMap->ApduBufferSize-NdefMap->ApduBuffIndex )== 0 && NdefMap->Felica.CurBlockNo < NdefMap->FelicaAttrInfo.Nmaxb )*/
649 else
650 {
651 if (( ( NdefMap->ApduBufferSize-NdefMap->ApduBuffIndex )== 0) &&
652 (NdefMap->Felica.CurBlockNo == Nbc ))
653 {
654 status = PHNFCSTVAL(CID_NFC_NONE,
655 NFCSTATUS_SUCCESS);
656
657 ResetFlag = ((NdefMap->Felica.Rd_NoBytesToCopy > 0 )?
658 FALSE:
659 TRUE);
660 if( ResetFlag== FALSE)
661 {
662 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex;
663 /*Reset the index, internal buffer counters back to zero*/
664 NdefMap->ApduBuffIndex = 0;
665 }
666 }/*if ((NdefMap->ApduBufferSize-NdefMap->ApduBuffIndex )== 0 && NdefMap->Felica.CurBlockNo == NdefMap->FelicaAttrInfo.Nmaxb )*/
667 else
668 {
669 /* reached reading all the blks available in the card: set EOF flag*/
670 if ( NdefMap->ApduBuffIndex == (Nbc*16))
671 {
672 status = PHNFCSTVAL(CID_NFC_NONE,
673 NFCSTATUS_SUCCESS);
674 ResetFlag = TRUE;
675 }
676 else
677 {
678 if ((NdefMap->ApduBufferSize-NdefMap->ApduBuffIndex )> 0 )
679 {
680 if ( NdefMap->Felica.CurBlockNo == Nbc )
681 {
682 /* bytes pending in internal buffer , No Space in User Buffer*/
683 if ( NdefMap->Felica.Rd_NoBytesToCopy > 0)
684 {
685 if ( NdefMap->Felica.EofCardReachedFlag == TRUE )
686 {
687 status = PHNFCSTVAL(CID_NFC_NONE,
688 NFCSTATUS_SUCCESS);
689 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex;
690 NdefMap->ApduBuffIndex=0;
691 }
692 else
693 {
694 phFriNfc_Felica_HAfterRead_CopyDataToBuff(NdefMap);
695 if( NdefMap->Felica.Rd_NoBytesToCopy > 0 )
696 {
697 status = PHNFCSTVAL(CID_NFC_NONE,
698 NFCSTATUS_SUCCESS);
699 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex;
700 NdefMap->ApduBuffIndex=0;
701 }
702 else
703 {
704 /* EOF Card Reached set the internal EOF Flag*/
705 status = PHNFCSTVAL(CID_NFC_NONE,
706 NFCSTATUS_SUCCESS);
707
708 ResetFlag = TRUE;
709 }
710 }
711 }
712 /* All bytes from internal buffer are copied and set eof flag*/
713 else
714 {
715 status = PHNFCSTVAL(CID_NFC_NONE,
716 NFCSTATUS_SUCCESS);
717 ResetFlag = TRUE;
718 }
719 }
720 else
721 {
722 /* This flag is set to ensure that, need of Read Opearation
723 we completed coying the data from internal buffer to external buffer
724 left some more bytes,in User bufer so initiate the read operation */
725 NdefMap->Felica.IntermediateRdFlag = TRUE;
726 }
727 }
728 else
729 {
730 status = PHNFCSTVAL(CID_NFC_NONE,
731 NFCSTATUS_SUCCESS);
732 }
733 }
734 }
735 if ( ResetFlag == TRUE)
736 {
737 PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0],
738 NdefMap->FelicaAttrInfo.LenBytes[1],
739 NdefMap->FelicaAttrInfo.LenBytes[2],
740 DataLen);
741 if (NdefMap->ApduBuffIndex > DataLen)
742 {
743 *NdefMap->NumOfBytesRead = DataLen;
744 }
745 else
746 {
747 *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex;
748 }
749 /*Reset the index, internal buffer counters back to zero*/
750 NdefMap->ApduBuffIndex = 0;
751 NdefMap->Felica.Rd_NoBytesToCopy=0;
752 NdefMap->Felica.EofCardReachedFlag=FELICA_RD_WR_EOF_CARD_REACHED;
753
754 }
755
756 }
757 return( status);
758 }
759
760 /*!
761 * \brief Used in Read Opearation.Sets the transceive Command for read.
762 */
phFriNfc_Felica_HSetTransceiveForRead(phFriNfc_NdefMap_t * NdefMap,uint16_t TrxLen,uint8_t Offset)763 static NFCSTATUS phFriNfc_Felica_HSetTransceiveForRead(phFriNfc_NdefMap_t *NdefMap,uint16_t TrxLen,uint8_t Offset)
764 {
765 NFCSTATUS TrxStatus = NFCSTATUS_PENDING;
766 uint16_t BufIndex=0,i=0;
767
768 /* set the felica cmd */
769 #ifdef PH_HAL4_ENABLE
770 NdefMap->Cmd.FelCmd = phHal_eFelica_Raw;
771 #else
772 NdefMap->Cmd.FelCmd = phHal_eFelicaCmdListFelicaCmd;
773 #endif /* #ifdef PH_HAL4_ENABLE */
774
775 /*Change the state to Read */
776 NdefMap->State = PH_NFCFRI_NDEFMAP_FELI_STATE_RD_BLOCK;
777
778 /* set the complition routines for the mifare operations */
779 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_Felica_Process;
780 NdefMap->MapCompletionInfo.Context = NdefMap;
781
782 /*set the additional informations for the data exchange*/
783 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
784 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0;
785
786 /* pkt len : updated at the end*/
787 NdefMap->SendRecvBuf[BufIndex] = 0x00;
788 BufIndex ++;
789
790 NdefMap->SendRecvBuf[BufIndex] = 0x06;
791 BufIndex++;
792
793 /* IDm - Manufacturer Id : 8bytes*/
794 #ifdef PH_HAL4_ENABLE
795 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
796 (void * )(&(NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm)),
797 8);
798 #else
799 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
800 (void * )(&(NdefMap->psRemoteDevInfo->RemoteDevInfo.CardInfo212_424.Startup212_424.NFCID2t)),
801 8);
802 #endif /* #ifdef PH_HAL4_ENABLE */
803
804 BufIndex+=8;
805
806 /*Number of Services (n=1 ==> 0x80)*/
807 NdefMap->SendRecvBuf[BufIndex] = 0x01;
808 BufIndex++;
809
810 /*Service Code List*/
811 NdefMap->SendRecvBuf[BufIndex] = 0x0B;
812 BufIndex++;
813
814 NdefMap->SendRecvBuf[BufIndex] = 0x00;
815 BufIndex++;
816
817 /*Number of Blocks to read*/
818 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(TrxLen/16);
819 BufIndex++;
820 /* Set the Blk numbers as per the offset set by the user : Block List*/
821 if ( Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN )
822 {
823 for ( i=0;i<(TrxLen/16);i++)
824 {
825 /*1st Service Code list : byte 1*/
826 NdefMap->SendRecvBuf[BufIndex] = 0x80;
827 BufIndex++;
828
829 /* No. Of Blocks*/
830 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(i + 1);
831 BufIndex++;
832 }
833 }
834 else
835 {
836 for ( i= 1;i<=(TrxLen/16);i++)
837 {
838 /*1st Service Code list : byte 1*/
839 NdefMap->SendRecvBuf[BufIndex] = 0x80;
840 BufIndex++;
841
842 /* No. Of Blocks*/
843 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(NdefMap->Felica.CurBlockNo + i);
844 BufIndex++;
845 }
846 }
847
848 /* len of entire pkt*/
849 NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = (uint8_t) BufIndex;
850
851 /* Set the Pkt Len*/
852 NdefMap->SendLength = BufIndex;
853
854 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
855
856 TrxStatus = phFriNfc_OvrHal_Transceive(NdefMap->LowerDevice,
857 &NdefMap->MapCompletionInfo,
858 NdefMap->psRemoteDevInfo,
859 NdefMap->Cmd,
860 &NdefMap->psDepAdditionalInfo,
861 NdefMap->SendRecvBuf,
862 NdefMap->SendLength,
863 NdefMap->SendRecvBuf,
864 NdefMap->SendRecvLength);
865 return (TrxStatus);
866 }
867
868 /*!
869 * \brief Initiates Writing of NDEF information to the Remote Device.
870 *
871 * The function initiates the writing of NDEF information to a Remote Device.
872 * It performs a reset of the state and starts the action (state machine).
873 * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action
874 * has been triggered.
875 */
876
phFriNfc_Felica_WrNdef(phFriNfc_NdefMap_t * NdefMap,uint8_t * PacketData,uint32_t * PacketDataLength,uint8_t Offset)877 NFCSTATUS phFriNfc_Felica_WrNdef( phFriNfc_NdefMap_t *NdefMap,
878 uint8_t *PacketData,
879 uint32_t *PacketDataLength,
880 uint8_t Offset)
881 {
882
883 NFCSTATUS status = NFCSTATUS_PENDING;
884
885 NdefMap->ApduBufferSize = *PacketDataLength;
886 /*Store the packet data buffer*/
887 NdefMap->ApduBuffer = PacketData;
888
889 /* To Update the Acutal written bytes to context*/
890 NdefMap->WrNdefPacketLength = PacketDataLength;
891 *NdefMap->WrNdefPacketLength = 0;
892
893
894 NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE;
895 NdefMap->Felica.Offset = Offset;
896
897 NdefMap->Felica.OpFlag = PH_FRINFC_NDEFMAP_FELI_WR_ATTR_RD_OP;
898 status = phFriNfc_Felica_HRdAttrInfo(NdefMap);
899 /* handle the error in Transc function*/
900 if ( (status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
901 {
902 /* call respective CR */
903 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_CHK_NDEF,status);
904 }
905 return (status);
906 }
907
908 /*!
909 * \brief Initiates Writing of Empty NDEF information to the Remote Device.
910 *
911 * The function initiates the writing empty of NDEF information to a Remote Device.
912 * It performs a reset of the state and starts the action (state machine).
913 * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action
914 * has been triggered.
915 */
916
phFriNfc_Felica_EraseNdef(phFriNfc_NdefMap_t * NdefMap)917 NFCSTATUS phFriNfc_Felica_EraseNdef( phFriNfc_NdefMap_t *NdefMap)
918 {
919
920 NFCSTATUS status = NFCSTATUS_PENDING;
921 static uint32_t PktDtLength =0;
922
923 if ( NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID )
924 {
925 /* Card is in invalid state, cannot have any read/write
926 operations*/
927 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
928 NFCSTATUS_INVALID_FORMAT);
929 }
930 else if ( NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY )
931 {
932 /*Can't write to the card :No Grants */
933 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
934 NFCSTATUS_WRITE_FAILED);
935 /* set the no. bytes written is zero*/
936 NdefMap->WrNdefPacketLength = &PktDtLength;
937 *NdefMap->WrNdefPacketLength = 0;
938 }
939 else
940 {
941
942 /* set the Operation*/
943 NdefMap->Felica.OpFlag = PH_FRINFC_NDEFMAP_FELI_WR_EMPTY_MSG_OP;
944
945 status = phFriNfc_Felica_HRdAttrInfo(NdefMap);
946 }
947 return (status);
948 }
949
950
951 /*!
952 * \brief Used in Write Opearation.
953 * check the value set for the Write Flag, in first write operation(begin), sets the
954 * WR flag in attribute blck.
955 * After a successful write operation, This function sets the WR flag off and updates
956 * the LEN bytes in attribute Block.
957 */
958
phFriNfc_Felica_HUpdateAttrBlkForWrOp(phFriNfc_NdefMap_t * NdefMap,uint8_t isStarted)959 static NFCSTATUS phFriNfc_Felica_HUpdateAttrBlkForWrOp(phFriNfc_NdefMap_t *NdefMap,uint8_t isStarted)
960 {
961 NFCSTATUS status = NFCSTATUS_PENDING;
962
963 uint16_t ChkSum=0,index=0;
964 uint8_t BufIndex=0, ErrFlag = FALSE;
965 uint32_t TotNoWrittenBytes=0;
966
967 /* Write Operation : Begin/End Check*/
968
969 NdefMap->State =
970 (( isStarted == FELICA_WRITE_STARTED )?
971 PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_BEGIN:
972 PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_END);
973
974 if( ( NdefMap->State == PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_BEGIN)||
975 ( NdefMap->State == PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_END) )
976 {
977
978 /* Set the Felica Cmd*/
979 #ifdef PH_HAL4_ENABLE
980 NdefMap->Cmd.FelCmd = phHal_eFelica_Raw;
981 #else
982 NdefMap->Cmd.FelCmd = phHal_eFelicaCmdListFelicaCmd;
983 #endif /* #ifdef PH_HAL4_ENABLE */
984
985 /* 1st byte represents the length of the cmd packet*/
986 NdefMap->SendRecvBuf[BufIndex] = 0x00;
987 BufIndex++;
988
989 /* Write/Update command code*/
990 NdefMap->SendRecvBuf[BufIndex] = 0x08;
991 BufIndex++;
992
993 /* IDm - Manufacturer Id : 8bytes*/
994 #ifdef PH_HAL4_ENABLE
995 (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])),
996 (void*)(&(NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm)),
997 8);
998 #else
999 (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])),
1000 (void*)(&(NdefMap->psRemoteDevInfo->RemoteDevInfo.CardInfo212_424.Startup212_424.NFCID2t)),
1001 8);
1002 #endif /* #ifdef PH_HAL4_ENABLE */
1003
1004 BufIndex+=8;
1005
1006 NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Services (n=1 ==> 0x80)*/
1007 BufIndex++;
1008
1009 NdefMap->SendRecvBuf[BufIndex] = 0x09; /* Service Code List*/
1010 BufIndex++;
1011
1012 NdefMap->SendRecvBuf[BufIndex] = 0x00; /* Service Code List*/
1013 BufIndex++;
1014
1015 NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Blocks to Write*/
1016 BufIndex++;
1017
1018 NdefMap->SendRecvBuf[BufIndex] = 0x80; /* 1st Block Element : byte 1*/
1019 BufIndex++;
1020
1021 NdefMap->SendRecvBuf[BufIndex] = 0x00; /* 1st Block Element : byte 2, block 1*/
1022 BufIndex++;
1023
1024 /* Fill Attribute Blk Information*/
1025 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Version;
1026 BufIndex++;
1027
1028 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Nbr;
1029 BufIndex++;
1030
1031 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Nbw;
1032 BufIndex++;
1033
1034 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)((NdefMap->FelicaAttrInfo.Nmaxb) >> 8);
1035 BufIndex++;
1036
1037 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)((NdefMap->FelicaAttrInfo.Nmaxb) & (0x00ff));
1038 BufIndex++;
1039
1040 NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/
1041 BufIndex++;
1042
1043 NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/
1044 BufIndex++;
1045
1046 NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/
1047 BufIndex++;
1048
1049 NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/
1050 BufIndex++;
1051
1052 if (isStarted == FELICA_WRITE_STARTED )
1053 {
1054 NdefMap->SendRecvBuf[BufIndex] = 0x0F; /* Write Flag Made On*/
1055 BufIndex++;
1056
1057 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.RdWrFlag; /* Read write flag*/
1058 BufIndex++;
1059
1060 /* Len Bytes*/
1061 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.LenBytes[0];
1062 BufIndex++;
1063
1064 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.LenBytes[1];
1065 BufIndex++;
1066
1067 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.LenBytes[2];
1068 BufIndex++;
1069 }
1070 else
1071 {
1072 /* Case: Previous Write Operation failed and integration context continues with write
1073 operation with offset set to Current. In this case, if we find Internal Bytes remained in the
1074 felica context is true(>0) and current block number is Zero. Then we shouldn't allow the module
1075 to write the data to card, as this is a invalid case*/
1076 if ( (NdefMap->Felica.Wr_BytesRemained > 0) && (NdefMap->Felica.CurBlockNo == 0))
1077 {
1078 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1079 NFCSTATUS_INVALID_PARAMETER);
1080 ErrFlag = TRUE;
1081 }
1082 else
1083 {
1084
1085 NdefMap->SendRecvBuf[BufIndex] = 0x00; /* Write Flag Made Off*/
1086 BufIndex++;
1087
1088 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.RdWrFlag; /* Read write flag*/
1089 BufIndex++;
1090
1091 if ( NdefMap->Felica.Wr_BytesRemained > 0 )
1092 {
1093 TotNoWrittenBytes = ( (NdefMap->Felica.CurBlockNo *16)- (16 - (NdefMap->Felica.Wr_BytesRemained)));
1094 }
1095 else
1096 {
1097 TotNoWrittenBytes = ( NdefMap->Felica.CurBlockNo *16);
1098
1099 }
1100
1101 /* Update Len Bytes*/
1102 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(( TotNoWrittenBytes & 0x00ff0000) >> 16);
1103 BufIndex++;
1104
1105 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)((TotNoWrittenBytes & 0x0000ff00) >> 8);
1106 BufIndex++;
1107
1108 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(TotNoWrittenBytes & 0x000000ff);
1109 BufIndex++;
1110 }
1111 }
1112
1113 if ( ErrFlag != TRUE )
1114 {
1115 /* check sum update*/
1116 for ( index = 16 ; index < 30 ; index ++)
1117 {
1118 ChkSum += NdefMap->SendRecvBuf[index];
1119 }
1120
1121 /* fill check sum in command pkt*/
1122 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(ChkSum >> 8);
1123 BufIndex++;
1124
1125 NdefMap->SendRecvBuf[BufIndex] = (uint8_t )(ChkSum & 0x00ff);
1126 BufIndex++;
1127
1128 /* update length of the cmd pkt*/
1129 NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex;
1130
1131 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
1132
1133 /* Update the Send Len*/
1134 NdefMap->SendLength = BufIndex;
1135
1136 /*set the completion routines for the desfire card operations*/
1137 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_NdefMap_Process;
1138 NdefMap->MapCompletionInfo.Context = NdefMap;
1139
1140 /*set the additional informations for the data exchange*/
1141 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
1142 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0;
1143
1144 /*Call the Overlapped HAL Transceive function */
1145 status = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice,
1146 &NdefMap->MapCompletionInfo,
1147 NdefMap->psRemoteDevInfo,
1148 NdefMap->Cmd,
1149 &NdefMap->psDepAdditionalInfo,
1150 NdefMap->SendRecvBuf,
1151 NdefMap->SendLength,
1152 NdefMap->SendRecvBuf,
1153 NdefMap->SendRecvLength);
1154 }
1155 }
1156 else
1157 {
1158 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1159 NFCSTATUS_INVALID_PARAMETER);
1160
1161 }
1162 return (status);
1163 }
1164
phFriNfc_Felica_HWrEmptyMsg(phFriNfc_NdefMap_t * NdefMap)1165 static NFCSTATUS phFriNfc_Felica_HWrEmptyMsg(phFriNfc_NdefMap_t *NdefMap)
1166 {
1167 NFCSTATUS status = NFCSTATUS_PENDING;
1168
1169 uint16_t ChkSum=0,index=0;
1170 uint8_t BufIndex=0;
1171
1172 /* Write Operation : To Erase the present NDEF Data*/
1173
1174 NdefMap->State = PH_NFCFRI_NDEFMAP_FELI_STATE_WR_EMPTY_MSG;
1175
1176 /* Set the Felica Cmd*/
1177 #ifdef PH_HAL4_ENABLE
1178 NdefMap->Cmd.FelCmd = phHal_eFelica_Raw;
1179 #else
1180 NdefMap->Cmd.FelCmd = phHal_eFelicaCmdListFelicaCmd;
1181 #endif /* #ifdef PH_HAL4_ENABLE */
1182
1183 /* 1st byte represents the length of the cmd packet*/
1184 NdefMap->SendRecvBuf[BufIndex] = 0x00;
1185 BufIndex++;
1186
1187 /* Write/Update command code*/
1188 NdefMap->SendRecvBuf[BufIndex] = 0x08;
1189 BufIndex++;
1190
1191 /* IDm - Manufacturer Id : 8bytes*/
1192 #ifdef PH_HAL4_ENABLE
1193 (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])),
1194 (void*)(&(NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm)),
1195 8);
1196 #else
1197 (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])),
1198 (void*)(&(NdefMap->psRemoteDevInfo->RemoteDevInfo.CardInfo212_424.Startup212_424.NFCID2t)),
1199 8);
1200 #endif /* #ifdef PH_HAL4_ENABLE */
1201
1202
1203 BufIndex+=8;
1204
1205 NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Services (n=1 ==> 0x80)*/
1206 BufIndex++;
1207
1208 NdefMap->SendRecvBuf[BufIndex] = 0x09; /* Service Code List*/
1209 BufIndex++;
1210
1211 NdefMap->SendRecvBuf[BufIndex] = 0x00; /* Service Code List*/
1212 BufIndex++;
1213
1214 NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Blocks to Write*/
1215 BufIndex++;
1216
1217 NdefMap->SendRecvBuf[BufIndex] = 0x80; /* 1st Block Element : byte 1*/
1218 BufIndex++;
1219
1220 NdefMap->SendRecvBuf[BufIndex] = 0x00; /* 1st Block Element : byte 2, block 1*/
1221 BufIndex++;
1222
1223 /* Fill Attribute Blk Information*/
1224 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Version;
1225 BufIndex++;
1226
1227 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Nbr;
1228 BufIndex++;
1229
1230 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Nbw;
1231 BufIndex++;
1232
1233 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)((NdefMap->FelicaAttrInfo.Nmaxb) >> 8);
1234 BufIndex++;
1235
1236 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)((NdefMap->FelicaAttrInfo.Nmaxb) & (0x00ff));
1237 BufIndex++;
1238
1239 NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/
1240 BufIndex++;
1241
1242 NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/
1243 BufIndex++;
1244
1245 NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/
1246 BufIndex++;
1247
1248 NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/
1249 BufIndex++;
1250
1251 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.WriteFlag;
1252 BufIndex++;
1253
1254 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.RdWrFlag; /* Read write flag*/
1255 BufIndex++;
1256
1257 /* Len Bytes are set to 0 : Empty Msg*/
1258 NdefMap->SendRecvBuf[BufIndex] = 0x00;
1259 BufIndex++;
1260
1261 NdefMap->SendRecvBuf[BufIndex] = 0x00;
1262 BufIndex++;
1263
1264 NdefMap->SendRecvBuf[BufIndex] = 0x00;
1265 BufIndex++;
1266
1267 /* check sum update*/
1268 for ( index = 16 ; index < 30 ; index ++)
1269 {
1270 ChkSum += NdefMap->SendRecvBuf[index];
1271 }
1272
1273 /* fill check sum in command pkt*/
1274 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(ChkSum >> 8);
1275 BufIndex++;
1276
1277 NdefMap->SendRecvBuf[BufIndex] = (uint8_t )(ChkSum & 0x00ff);
1278 BufIndex++;
1279
1280 /* update length of the cmd pkt*/
1281 NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex;
1282
1283 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
1284
1285 /* Update the Send Len*/
1286 NdefMap->SendLength = BufIndex;
1287
1288 /*set the completion routines for the desfire card operations*/
1289 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_NdefMap_Process;
1290 NdefMap->MapCompletionInfo.Context = NdefMap;
1291
1292 /*set the additional informations for the data exchange*/
1293 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
1294 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0;
1295
1296 /*Call the Overlapped HAL Transceive function */
1297 status = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice,
1298 &NdefMap->MapCompletionInfo,
1299 NdefMap->psRemoteDevInfo,
1300 NdefMap->Cmd,
1301 &NdefMap->psDepAdditionalInfo,
1302 NdefMap->SendRecvBuf,
1303 NdefMap->SendLength,
1304 NdefMap->SendRecvBuf,
1305 NdefMap->SendRecvLength);
1306
1307 return (status);
1308 }
1309
1310
1311
1312
1313 /*!
1314 * \brief Used in Write Opearation.
1315 * This Function is called after a successful validation and storing of attribution block
1316 * content in to context.
1317 * If the write operation is initiated with begin,function initiates the write operation with
1318 * RdWr flag.
1319 * If the Offset is set to Current, Checks for the EOF card reached status and writes data to
1320 * The Card
1321 */
1322
phFriNfc_Felica_HChkAttrBlkForWrOp(phFriNfc_NdefMap_t * NdefMap)1323 static NFCSTATUS phFriNfc_Felica_HChkAttrBlkForWrOp(phFriNfc_NdefMap_t *NdefMap)
1324 {
1325 NFCSTATUS status = NFCSTATUS_PENDING;
1326 uint32_t DataLen=0;
1327
1328 /*check RW Flag Access Rights*/
1329 /* set to read only cannot write*/
1330 if ( NdefMap->FelicaAttrInfo.RdWrFlag == 0x00)
1331
1332 {
1333 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1334 NFCSTATUS_INVALID_DEVICE_REQUEST);
1335 }
1336 else
1337 {
1338 if ( ( NdefMap->Felica.Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) ||
1339 ( ( NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE) &&
1340 (NdefMap->Felica.Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN ) ))
1341 {
1342 /* check allready written number of bytes and apdu buffer size*/
1343 if (NdefMap->ApduBufferSize > (uint32_t)(NdefMap->FelicaAttrInfo.Nmaxb *16))
1344 {
1345 NdefMap->Felica.EofCardReachedFlag = FELICA_EOF_REACHED_WR_WITH_BEGIN_OFFSET;
1346 }
1347 else
1348 {
1349 NdefMap->Felica.EofCardReachedFlag = FALSE;
1350 }
1351
1352
1353 /* reset the internal variables initiate toupdate the attribute blk*/
1354 NdefMap->Felica.Wr_BytesRemained = 0;
1355 NdefMap->Felica.CurBlockNo = 0;
1356 NdefMap->Felica.NoBlocksWritten = 0;
1357 phFriNfc_Felica_HInitInternalBuf(NdefMap->Felica.Wr_RemainedBytesBuff);
1358 status= phFriNfc_Felica_HUpdateAttrBlkForWrOp(NdefMap,FELICA_WRITE_STARTED);
1359
1360 }
1361 else
1362 {
1363 if (NdefMap->Felica.Offset == PH_FRINFC_NDEFMAP_SEEK_CUR )
1364 {
1365 /* Calculate the Allready Written No. Of Blocks*/
1366 PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0],
1367 NdefMap->FelicaAttrInfo.LenBytes[1],
1368 NdefMap->FelicaAttrInfo.LenBytes[2],
1369 DataLen);
1370
1371 if (( NdefMap->ApduBufferSize + (DataLen )) >
1372 (uint32_t)( NdefMap->FelicaAttrInfo.Nmaxb *16))
1373 {
1374 if(( DataLen ) == (uint32_t)(NdefMap->FelicaAttrInfo.Nmaxb *16) )
1375 {
1376 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
1377 NFCSTATUS_EOF_NDEF_CONTAINER_REACHED);
1378 }
1379 else
1380 {
1381
1382 NdefMap->Felica.EofCardReachedFlag =FELICA_EOF_REACHED_WR_WITH_CURR_OFFSET;
1383 NdefMap->ApduBuffIndex =0;
1384 NdefMap->Felica.NoBlocksWritten = 0;
1385 status= phFriNfc_Felica_HUpdateAttrBlkForWrOp(NdefMap,FELICA_WRITE_STARTED);
1386 }
1387 }
1388 else
1389 {
1390 NdefMap->ApduBuffIndex =0;
1391 NdefMap->Felica.NoBlocksWritten = 0;
1392 status= phFriNfc_Felica_HUpdateAttrBlkForWrOp(NdefMap,FELICA_WRITE_STARTED);
1393 }
1394 }/*if (NdefMap->Felica.Offset == PH_FRINFC_NDEFMAP_SEEK_CUR )*/
1395 }
1396 }
1397 return (status);
1398 }
1399
1400 /*!
1401 * \brief Used in Read Opearation.
1402 * This Function is called after a successful validation and storing of attribution block
1403 * content in to context.
1404 * While Offset is set to Current, Checks for the EOF card reached status and reads data from
1405 * The Card
1406 */
1407
phFriNfc_Felica_HChkAttrBlkForRdOp(phFriNfc_NdefMap_t * NdefMap,uint32_t NdefLen)1408 static NFCSTATUS phFriNfc_Felica_HChkAttrBlkForRdOp(phFriNfc_NdefMap_t *NdefMap,
1409 uint32_t NdefLen)
1410 {
1411 NFCSTATUS status = NFCSTATUS_PENDING;
1412
1413 /*check WR Flag Access Rights*/
1414 /* set to still writing data state only cannot Read*/
1415 if ( NdefMap->FelicaAttrInfo.WriteFlag == 0x0F )
1416 {
1417 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,NFCSTATUS_READ_FAILED);
1418 /* As we are not able to continue with reading data
1419 bytes read set to zero*/
1420 *NdefMap->NumOfBytesRead = 0;
1421 }
1422 else
1423 {
1424 status = phFriNfc_MapTool_SetCardState( NdefMap,NdefLen);
1425 if ( status == NFCSTATUS_SUCCESS)
1426 {
1427 /* Read data From the card*/
1428 status = phFriNfc_Felica_HReadData(NdefMap,NdefMap->Felica.Offset);
1429 }
1430 }
1431
1432 return (status);
1433 }
1434
1435 /*!
1436 * \brief Used in Write Opearation.
1437 * This function writes the data in terms of blocks.
1438 * Each write operation supports,minimum Nbw blocks of bytes.
1439 * Also checks for the EOF,>=NBW,<NBW etc
1440 */
phFriNfc_Felica_HUpdateData(phFriNfc_NdefMap_t * NdefMap)1441 static NFCSTATUS phFriNfc_Felica_HUpdateData(phFriNfc_NdefMap_t *NdefMap)
1442 {
1443 NFCSTATUS status = NFCSTATUS_PENDING;
1444
1445 uint8_t BufIndex=0,
1446 i=0,
1447 BlkNo=0,
1448 PadBytes=0,
1449 CurBlk=1,
1450 NoOfBlks=0,
1451 NbwCheck=0,
1452 TotNoBlks=0;
1453
1454 uint32_t BytesRemainedInCard=0,
1455 BytesRemained=0,
1456 TotNoWrittenBytes=0;
1457
1458 if( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) > 0 )
1459 {
1460 /* Prepare the write cmd pkt for felica*/
1461 /* 1st byte represents the length of the cmd packet*/
1462 NdefMap->SendRecvBuf[BufIndex] = 0x00;
1463 BufIndex++;
1464
1465 /* Write/Update command code*/
1466 NdefMap->SendRecvBuf[BufIndex] = 0x08;
1467 BufIndex++;
1468
1469 /* IDm - Manufacturer Id : 8bytes*/
1470 #ifdef PH_HAL4_ENABLE
1471 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
1472 (&(NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm)),
1473 8);
1474 #else
1475 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
1476 (&(NdefMap->psRemoteDevInfo->RemoteDevInfo.CardInfo212_424.Startup212_424.NFCID2t)),
1477 8);
1478 #endif /* #ifdef PH_HAL4_ENABLE */
1479
1480 BufIndex+=8;
1481
1482 NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Services (n=1 ==> 0x80)*/
1483 BufIndex++;
1484
1485 NdefMap->SendRecvBuf[BufIndex] = 0x09; /* Service Code List*/
1486 BufIndex++;
1487
1488 NdefMap->SendRecvBuf[BufIndex] = 0x00; /* Service Code List*/
1489 BufIndex++;
1490
1491 if ( NdefMap->Felica.EofCardReachedFlag == FELICA_EOF_REACHED_WR_WITH_BEGIN_OFFSET)
1492 {
1493 /* check for the eof card reached flag.Need to write only mamximum bytes(memory)to card.
1494 Used when, offset set to begin case*/
1495 BytesRemainedInCard= ( (NdefMap->FelicaAttrInfo.Nmaxb*16) - (NdefMap->Felica.CurBlockNo * 16));
1496 }
1497 else
1498 {
1499 /* Offset : Cuurent*/
1500 if ( NdefMap->Felica.EofCardReachedFlag == FELICA_EOF_REACHED_WR_WITH_CURR_OFFSET )
1501 {
1502 /* caculate previously written Ndef blks*/
1503 (void)phFriNfc_Felica_HGetMaximumBlksToRead(NdefMap,PH_NFCFRI_NDEFMAP_FELI_NBC);
1504
1505 if ( NdefMap->Felica.Wr_BytesRemained )
1506 {
1507 TotNoWrittenBytes = ( (NdefMap->Felica.CurBlockNo *16)- (16 - (NdefMap->Felica.Wr_BytesRemained)));
1508 }
1509 else
1510 {
1511 TotNoWrittenBytes = ( NdefMap->Felica.CurBlockNo *16);
1512 }
1513 /* Determine exactly, how many bytes we can write*/
1514 BytesRemainedInCard = (NdefMap->FelicaAttrInfo.Nmaxb*16 - (TotNoWrittenBytes));
1515 }
1516
1517 }
1518 /* Write Data Pending in the Internal Buffer*/
1519 if(NdefMap->Felica.Wr_BytesRemained > 0)
1520 {
1521 /* update the number of blocks to write with the block list elements*/
1522 /* Total Number of blocks to write*/
1523 NdefMap->SendRecvBuf[BufIndex] = 0;
1524 BufIndex++;
1525
1526 /* Update this Total no. Bloks later*/
1527 NoOfBlks = BufIndex;
1528
1529 /* As we are writing atleast one block*/
1530 TotNoBlks = 1;
1531
1532 /* check do we have some extra bytes to write? in User Buffer*/
1533 if ( NdefMap->ApduBufferSize >(uint32_t) (16 - NdefMap->Felica.Wr_BytesRemained))
1534 {
1535 /* Have we reached EOF?*/
1536 if ( NdefMap->Felica.EofCardReachedFlag )
1537 {
1538 BytesRemained = BytesRemainedInCard;
1539 }
1540 else
1541 {
1542 /* This value tells how many extra bytes we can write other than internal buffer bytes*/
1543 BytesRemained = (uint8_t)NdefMap->ApduBufferSize - (16 - NdefMap->Felica.Wr_BytesRemained);
1544 }
1545
1546 if ( BytesRemained )
1547 {
1548 /* Not reached EOF*/
1549 if (!NdefMap->Felica.EofCardReachedFlag)
1550 {
1551 /* Calculate How many blks we need to write*/
1552 BlkNo =((uint8_t)( BytesRemained )/16);
1553
1554 /* check blocks to write exceeds nbw*/
1555 if ( BlkNo >= NdefMap->FelicaAttrInfo.Nbw )
1556 {
1557 BlkNo = NdefMap->FelicaAttrInfo.Nbw;
1558 /* No. Blks to write are more than Nbw*/
1559 NbwCheck = 1;
1560 }
1561 else
1562 {
1563 if ((( BytesRemained %16) == 0)&& (BlkNo == 0 ))
1564 {
1565 BlkNo=1;
1566 }
1567 }
1568 /* check do we need pad bytes?*/
1569 if( (!NbwCheck && (uint8_t)( BytesRemained)%16) != 0)
1570 {
1571 BlkNo++;
1572 PadBytes = (BlkNo * 16) - (uint8_t)( BytesRemained);
1573 NdefMap->Felica.PadByteFlag = TRUE;
1574 NdefMap->Felica.NoBlocksWritten = BlkNo;
1575 TotNoBlks += BlkNo;
1576
1577 }
1578 else
1579 {
1580 if ( NbwCheck )
1581 {
1582 /* as we have to write only 8 blocks and already we have pad bytes so we have
1583 to strat from previous block*/
1584 TotNoBlks += BlkNo - 1;
1585 NdefMap->Felica.NoBlocksWritten = TotNoBlks-1;
1586 }
1587 else
1588 {
1589 if ( !(BytesRemained - (16 -NdefMap->Felica.Wr_BytesRemained)== 0 ))
1590 {
1591 TotNoBlks += BlkNo;
1592 }
1593 else
1594 {
1595
1596 }
1597 if ( NdefMap->Felica.PadByteFlag )
1598 {
1599 NdefMap->Felica.NoBlocksWritten = TotNoBlks-1;
1600
1601 }
1602 }
1603 }
1604 }
1605 else
1606 {
1607 /* we have reached the eof card & hv bytes to write*/
1608 BlkNo =(uint8_t)(( BytesRemained - ((16 -NdefMap->Felica.Wr_BytesRemained)) )/16);
1609
1610 /* check are we exceeding the NBW limit, while a write?*/
1611 if ( BlkNo >= NdefMap->FelicaAttrInfo.Nbw )
1612 {
1613 BlkNo = NdefMap->FelicaAttrInfo.Nbw;
1614
1615 /* No. Blks to write are more than Nbw*/
1616 NbwCheck = 1;
1617
1618 }
1619 else
1620 {
1621 if ((( BytesRemained %16) == 0)&& (BlkNo == 0 ))
1622 {
1623 BlkNo=1;
1624 }
1625 }
1626
1627 /*check Total how many blocks to write*/
1628 if(((!NbwCheck) &&( BytesRemained- (16 - NdefMap->Felica.Wr_BytesRemained))%16) != 0)
1629 {
1630 BlkNo++;
1631 PadBytes = (BlkNo * 16) - (uint8_t)( BytesRemained);
1632 NdefMap->Felica.PadByteFlag = TRUE;
1633 NdefMap->Felica.NoBlocksWritten = BlkNo;
1634 TotNoBlks += BlkNo;
1635
1636 }
1637 else
1638 {
1639 if ( NbwCheck )
1640 {
1641 /* as we have to write only 8 blocks and already we have pad bytes so we have
1642 to strat from previous last block*/
1643 TotNoBlks += BlkNo - 1;
1644 NdefMap->Felica.NoBlocksWritten = TotNoBlks-1;
1645 }
1646 else
1647 {
1648 /* we need to write only one block ( bytesremanind + internal buffer size = 16)*/
1649 if ( !(BytesRemained - (16 -NdefMap->Felica.Wr_BytesRemained)== 0 ))
1650 {
1651 TotNoBlks += BlkNo;
1652 }
1653 else
1654 {
1655 ;/* we are not incrementing the Total no. of blocks to write*/
1656 }
1657
1658 if ( NdefMap->Felica.PadByteFlag )
1659 {
1660 NdefMap->Felica.NoBlocksWritten = TotNoBlks -1;
1661
1662 }
1663 }
1664 }
1665 }
1666 }/*if ( BytesRemained )*/
1667 else
1668 {
1669 ; /*Nothing to process here*/
1670 }
1671 }/*if ( NdefMap->ApduBufferSize >(uint32_t) (16 - NdefMap->Felica.Wr_BytesRemained))*/
1672 else
1673 {
1674 /* No new blks to write*/
1675 NdefMap->Felica.NoBlocksWritten = 0;
1676 }
1677 /* Prepare the Blk List for Write Operation*/
1678 /* Block List for NBw : 1st byte : two byte len list: 2nd byte is the block number*/
1679 for ( i=0; i< TotNoBlks; i++)
1680 {
1681 NdefMap->SendRecvBuf[BufIndex] = 0x80;
1682 BufIndex++;
1683 /* remember the previous Blk no and continue from there*/
1684 if ( NdefMap->Felica.PadByteFlag == TRUE )
1685 {
1686 NdefMap->SendRecvBuf[BufIndex] = NdefMap->Felica.CurBlockNo + i;
1687 BufIndex++;
1688 }
1689 else
1690 {
1691 CurBlk = NdefMap->Felica.CurBlockNo +1;
1692 NdefMap->SendRecvBuf[BufIndex] = CurBlk + i;
1693 BufIndex++;
1694 }
1695 }
1696 /* Copy relevant data to Transc buffer*/
1697 if((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= (uint32_t)(16 - NdefMap->Felica.Wr_BytesRemained))
1698 {
1699
1700 /*Copy the Remained bytes from the internal buffer to trxbuffer */
1701 (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])),
1702 NdefMap->Felica.Wr_RemainedBytesBuff,
1703 NdefMap->Felica.Wr_BytesRemained);
1704
1705 /*Increment the buff index*/
1706 BufIndex += NdefMap->Felica.Wr_BytesRemained;
1707
1708
1709 /*append copy 16-bytesToPad to trxBuffer*/
1710 (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])),
1711 (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
1712 (16 - NdefMap->Felica.Wr_BytesRemained));
1713
1714 /* Update Number Of Bytes Writtened*/
1715 NdefMap->NumOfBytesWritten = 16 - NdefMap->Felica.Wr_BytesRemained;
1716
1717 /* increment the index*/
1718 BufIndex += 16 - NdefMap->Felica.Wr_BytesRemained;
1719
1720 if ( BytesRemained )
1721 {
1722 if (!NdefMap->Felica.EofCardReachedFlag)
1723 {
1724 /* check nbw limit*/
1725 if ( NbwCheck != 1 )
1726 {
1727 /* Copy Extra Bytes other than the internal buffer bytes*/
1728 (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])),
1729 (&(NdefMap->ApduBuffer[(16 - NdefMap->Felica.Wr_BytesRemained)])),
1730 (NdefMap->ApduBufferSize - (16 - NdefMap->Felica.Wr_BytesRemained)));
1731
1732
1733 /* Update Number Of Bytes Writtened*/
1734 NdefMap->NumOfBytesWritten += (uint16_t)(NdefMap->ApduBufferSize - (16 - NdefMap->Felica.Wr_BytesRemained));
1735
1736 BufIndex += (uint8_t)(NdefMap->ApduBufferSize - (16 - NdefMap->Felica.Wr_BytesRemained));
1737
1738 if ( PadBytes )
1739 {
1740 for(i= 0; i< PadBytes; i++)
1741 {
1742 NdefMap->SendRecvBuf[BufIndex] =0x00;
1743 BufIndex++;
1744 }
1745 /* no of bytes remained copy*/
1746 NdefMap->Felica.Wr_BytesRemained = (uint8_t)(16 - PadBytes);
1747
1748 /*copy the data to internal buffer : Bytes remained*/
1749 (void)memcpy( NdefMap->Felica.Wr_RemainedBytesBuff,
1750 (&( NdefMap->ApduBuffer[(NdefMap->ApduBufferSize - NdefMap->Felica.Wr_BytesRemained)])),
1751 ( NdefMap->Felica.Wr_BytesRemained));
1752 }
1753 else
1754 {
1755 /* No Bytes in Internal buffer*/
1756 NdefMap->Felica.Wr_BytesRemained = 0;
1757 }
1758
1759 }
1760 else
1761 {
1762
1763 /*Copy Nbw*16 bytes of data to the trx buffer*/
1764 (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])),
1765 (&(NdefMap->ApduBuffer[(16 - NdefMap->Felica.Wr_BytesRemained)])),
1766 (NdefMap->FelicaAttrInfo.Nbw - 1) * 16);
1767
1768 /* increment the Buffindex*/
1769 BufIndex += ((NdefMap->FelicaAttrInfo.Nbw - 1 )*16);
1770
1771 NdefMap->Felica.Wr_BytesRemained = 0;
1772 NdefMap->NumOfBytesWritten+= ((NdefMap->FelicaAttrInfo.Nbw -1)*16);
1773 NdefMap->Felica.PadByteFlag =FALSE;
1774 }
1775 }/*if (!NdefMap->Felica.EofCardReachedFlag)*/
1776 else
1777 {
1778 /* check nbw limit*/
1779 if ( NbwCheck != 1 )
1780 {
1781 /* handle EOF card reached case*/
1782 (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])),
1783 (&(NdefMap->ApduBuffer[(16 - NdefMap->Felica.Wr_BytesRemained)])),
1784 ( BytesRemained - ((16 -NdefMap->Felica.Wr_BytesRemained) )));
1785
1786 /* Update Number Of Bytes Writtened*/
1787 NdefMap->NumOfBytesWritten += (uint16_t)( BytesRemained - (16 -NdefMap->Felica.Wr_BytesRemained));
1788
1789 BufIndex += (uint8_t)( BytesRemained - (16 -NdefMap->Felica.Wr_BytesRemained));
1790
1791 if ( PadBytes )
1792 {
1793 for(i= 0; i< PadBytes; i++)
1794 {
1795 NdefMap->SendRecvBuf[BufIndex] =0x00;
1796 BufIndex++;
1797 }
1798
1799 /*no of bytes remained copy*/
1800 NdefMap->Felica.Wr_BytesRemained = (uint8_t)(16 - PadBytes);
1801
1802 /*copy the data to internal buffer : Bytes remained*/
1803 (void)memcpy(NdefMap->Felica.Wr_RemainedBytesBuff,
1804 (&(NdefMap->ApduBuffer[(NdefMap->ApduBufferSize - NdefMap->Felica.Wr_BytesRemained)])),
1805 (NdefMap->Felica.Wr_BytesRemained));
1806
1807 }
1808 else
1809 {
1810 NdefMap->Felica.Wr_BytesRemained = 0;
1811 }
1812 }
1813 else
1814 {
1815
1816 /*Copy Nbw*16 bytes of data to the trx buffer*/
1817 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
1818 (&(NdefMap->ApduBuffer[(16 - NdefMap->Felica.Wr_BytesRemained)])),
1819 (NdefMap->FelicaAttrInfo.Nbw - 1) * 16);
1820
1821 /* increment the Buffindex*/
1822 BufIndex += ((NdefMap->FelicaAttrInfo.Nbw - 1 )*16);
1823
1824 NdefMap->Felica.Wr_BytesRemained = 0;
1825 NdefMap->NumOfBytesWritten+= ((NdefMap->FelicaAttrInfo.Nbw -1)*16);
1826
1827 NdefMap->Felica.PadByteFlag =FALSE;
1828 }
1829 }
1830 }/*if ( BytesRemained )*/
1831 else
1832 {
1833 NdefMap->Felica.Wr_BytesRemained = 0;
1834 }
1835 /* Update Total No. of blocks writtened*/
1836 NdefMap->SendRecvBuf[NoOfBlks -1 ]=TotNoBlks;
1837 }/*if((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= (uint32_t)(16 - NdefMap->Felica.Wr_BytesRemained))*/
1838 else
1839 {
1840 /*copy the internal buffer data to trx buffer*/
1841 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
1842 NdefMap->Felica.Wr_RemainedBytesBuff,
1843 (NdefMap->Felica.Wr_BytesRemained));
1844
1845 /* increment the index*/
1846 BufIndex+=NdefMap->Felica.Wr_BytesRemained;
1847
1848 /*append the apdusize data to the trx buffer*/
1849 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
1850 (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
1851 NdefMap->ApduBufferSize);
1852
1853 /* Index increment*/
1854 BufIndex+= (uint8_t)NdefMap->ApduBufferSize;
1855
1856 /* Tells how many bytes present in the internal buffer*/
1857 BytesRemained = NdefMap->Felica.Wr_BytesRemained + NdefMap->ApduBufferSize;
1858
1859 PadBytes = (uint8_t)(16-BytesRemained);
1860
1861 /* Pad empty bytes with Zeroes to complete 16 bytes*/
1862 for(i= 0; i< PadBytes; i++)
1863 {
1864 NdefMap->SendRecvBuf[BufIndex] =0x00;
1865 BufIndex++;
1866 }
1867
1868 /* Update Number Of Bytes Writtened*/
1869 NdefMap->NumOfBytesWritten = (uint16_t)NdefMap->ApduBufferSize;
1870
1871 /* Flag set to understand that , we have received less no. of bytes than
1872 present in the internal buffer*/
1873 NdefMap->Felica.IntermediateWrFlag = TRUE;
1874
1875 if ( NdefMap->Felica.PadByteFlag )
1876 {
1877 NdefMap->Felica.NoBlocksWritten = 0;
1878 }
1879 }
1880
1881 NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex;
1882 NdefMap->SendLength = BufIndex;
1883 /* Update Total No. of blocks writtened*/
1884 NdefMap->SendRecvBuf[NoOfBlks -1 ]=TotNoBlks;
1885 }
1886 else
1887 {
1888 /*Fresh write, starting from a new block*/
1889 if ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= (uint32_t)(16* NdefMap->FelicaAttrInfo.Nbw ))
1890 {
1891 /* check for the card size and write Nbw Blks*/
1892 if ( NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo >= NdefMap->FelicaAttrInfo.Nbw)
1893 {
1894 /* update the number of blocks to write with the block list elements*/
1895 /* Total Number of blocks to write*/
1896 NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Nbw;
1897 BufIndex++;
1898
1899 /* Block List for NBw : 1st byte : two byte len list: 2nd byte is the block number*/
1900 for ( i=1; i<= NdefMap->FelicaAttrInfo.Nbw; i++)
1901 {
1902 NdefMap->SendRecvBuf[BufIndex] = 0x80;
1903 BufIndex++;
1904
1905 NdefMap->SendRecvBuf[BufIndex] = NdefMap->Felica.CurBlockNo + i;
1906 BufIndex++;
1907 }
1908 /*Copy Nbw*16 bytes of data to the trx buffer*/
1909
1910 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
1911 (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
1912 NdefMap->FelicaAttrInfo.Nbw * 16);
1913
1914 /* increment the Buffindex*/
1915 BufIndex += (NdefMap->FelicaAttrInfo.Nbw*16);
1916
1917 /* update the length*/
1918 NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex;
1919
1920 NdefMap->Felica.Wr_BytesRemained = 0;
1921 NdefMap->NumOfBytesWritten = (NdefMap->FelicaAttrInfo.Nbw*16);
1922 NdefMap->Felica.NoBlocksWritten = NdefMap->FelicaAttrInfo.Nbw;
1923
1924 /* update the Send length*/
1925 NdefMap->SendLength = BufIndex;
1926
1927 NdefMap->Felica.PadByteFlag = FALSE;
1928 }/*if ( NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo >= NdefMap->FelicaAttrInfo.Nbw)*/
1929 else
1930 {
1931 /* we need to write less than nbw blks*/
1932 /* update the number of blocks to write with the block list elements*/
1933 /* Total Number of blocks to write*/
1934 NdefMap->SendRecvBuf[BufIndex] = (uint8_t)( NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo);
1935 BufIndex++;
1936
1937 /* Block List for NBw : 1st byte : two byte len list: 2nd byte is the block number*/
1938 for ( i=1; i<= (NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo); i++)
1939 {
1940 NdefMap->SendRecvBuf[BufIndex] = 0x80;
1941 BufIndex++;
1942 NdefMap->SendRecvBuf[BufIndex] = NdefMap->Felica.CurBlockNo + i;
1943 BufIndex++;
1944 }
1945
1946 /*Copy Nbw*16 bytes of data to the trx buffer*/
1947 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
1948 (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
1949 (NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo)*16);
1950
1951 /* increment the Buffindex*/
1952 BufIndex += (uint8_t)((NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo )*16);
1953
1954 /* update the length*/
1955 NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex;
1956
1957 NdefMap->NumOfBytesWritten = ((NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo)*16);
1958 NdefMap->Felica.NoBlocksWritten = (uint8_t)(NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo);
1959
1960 /* update the Send length*/
1961 NdefMap->SendLength = BufIndex;
1962
1963 NdefMap->Felica.PadByteFlag =FALSE;
1964 NdefMap->Felica.Wr_BytesRemained = 0;
1965 }
1966 }/* if ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= (uint32_t)(16* NdefMap->FelicaAttrInfo.Nbw )) */
1967 else
1968 {
1969 /*chk eof reached*/
1970 if ( NdefMap->Felica.EofCardReachedFlag)
1971 {
1972 BlkNo =((uint8_t)(BytesRemainedInCard )/16);
1973 if(((uint8_t)( BytesRemainedInCard )%16) != 0)
1974 {
1975 BlkNo++;
1976 PadBytes = ((BlkNo * 16) - (uint8_t)(BytesRemainedInCard ));
1977 NdefMap->Felica.PadByteFlag = TRUE;
1978 }
1979 }
1980 else
1981 {
1982
1983 BlkNo =((uint8_t)( NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)/16);
1984 if(((uint8_t)( NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)%16) != 0)
1985 {
1986 BlkNo++;
1987 PadBytes = (BlkNo * 16) - (uint8_t)( NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
1988 NdefMap->Felica.PadByteFlag = TRUE;
1989
1990 }
1991
1992
1993 }
1994
1995 /* update the number of blocks to write with the block list elements*/
1996 /* Total Number of blocks to write*/
1997 NdefMap->SendRecvBuf[BufIndex] = BlkNo;
1998 BufIndex++;
1999
2000 NdefMap->Felica.NoBlocksWritten = BlkNo;
2001
2002 /* Block List for NBw : 1st byte : two byte len list: 2nd byte is the block number*/
2003 for ( i=0; i< BlkNo; i++)
2004 {
2005 NdefMap->SendRecvBuf[BufIndex] = 0x80;
2006 BufIndex++;
2007 {
2008 CurBlk = NdefMap->Felica.CurBlockNo +1;
2009 NdefMap->SendRecvBuf[BufIndex] = CurBlk + i;
2010 BufIndex++;
2011 }
2012 }
2013 if ( NdefMap->Felica.EofCardReachedFlag )
2014 {
2015 /*Copy last data to the trx buffer*/
2016 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
2017 (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
2018 BytesRemainedInCard );
2019
2020 /* increment the bufindex and bytes written*/
2021 BufIndex += (uint8_t )BytesRemainedInCard ;
2022 NdefMap->NumOfBytesWritten = (uint16_t)BytesRemainedInCard ;
2023 }
2024 else
2025 {
2026 /*Copy data to the trx buffer*/
2027 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
2028 (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])),
2029 (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex));
2030
2031 /* increment the bufindex and bytes written*/
2032 BufIndex += (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
2033 NdefMap->NumOfBytesWritten = (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex);
2034 }
2035 if ( PadBytes )
2036 {
2037 for(i= 0; i< PadBytes; i++)
2038 {
2039 NdefMap->SendRecvBuf[BufIndex] =0x00;
2040 BufIndex++;
2041 }
2042 /*no of bytes remained copy*/
2043 NdefMap->Felica.Wr_BytesRemained = (uint8_t)(16 - PadBytes);
2044
2045 if ( NdefMap->Felica.EofCardReachedFlag )
2046 {
2047 /*copy the data to internal buffer : Bytes remained*/
2048 (void)memcpy(NdefMap->Felica.Wr_RemainedBytesBuff,
2049 (&(NdefMap->ApduBuffer[((BytesRemainedInCard - (BytesRemainedInCard % 16)))])),
2050 ( NdefMap->Felica.Wr_BytesRemained));
2051
2052 }
2053 else
2054 {
2055 /*copy the data to internal buffer : Bytes remained*/
2056 (void)memcpy( NdefMap->Felica.Wr_RemainedBytesBuff,
2057 (&(NdefMap->ApduBuffer[((NdefMap->ApduBufferSize - NdefMap->Felica.Wr_BytesRemained))])),
2058 ( NdefMap->Felica.Wr_BytesRemained));
2059
2060 }
2061 }/*if ( PadBytes )*/
2062 else
2063 {
2064 NdefMap->Felica.Wr_BytesRemained = 0;
2065 NdefMap->Felica.PadByteFlag = FALSE;
2066 }
2067 /* update the pkt len*/
2068 NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex;
2069 NdefMap->SendLength = BufIndex;
2070 }
2071 }/* else of if ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= (uint32_t)(16* NdefMap->FelicaAttrInfo.Nbw )) */
2072 status = phFriNfc_Felica_HWriteDataBlk(NdefMap);
2073 }
2074 else
2075 {
2076 /*0 represents the write operation ended*/
2077 status = phFriNfc_Felica_HUpdateAttrBlkForWrOp(NdefMap,FELICA_WRITE_ENDED);
2078 }
2079 return (status);
2080 }
2081
2082
2083 /*!
2084 * \brief Used in Write Opearation.
2085 * This function prepares and sends transcc Cmd Pkt.
2086 */
2087
phFriNfc_Felica_HWriteDataBlk(phFriNfc_NdefMap_t * NdefMap)2088 static NFCSTATUS phFriNfc_Felica_HWriteDataBlk(phFriNfc_NdefMap_t *NdefMap)
2089 {
2090 NFCSTATUS status = NFCSTATUS_PENDING;
2091
2092 /*set the additional informations for the data exchange*/
2093 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
2094 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0;
2095
2096 /*Set the ISO14434 command*/
2097 #ifdef PH_HAL4_ENABLE
2098 NdefMap->Cmd.FelCmd = phHal_eFelica_Raw;
2099 #else
2100 NdefMap->Cmd.FelCmd = phHal_eFelicaCmdListFelicaCmd;
2101 #endif /* #ifdef PH_HAL4_ENABLE */
2102
2103 /* set the state*/
2104 NdefMap->State = PH_NFCFRI_NDEFMAP_FELI_STATE_WR_BLOCK;
2105
2106 /* set send receive length*/
2107 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
2108
2109 /*Call the Overlapped HAL Transceive function */
2110 status = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice,
2111 &NdefMap->MapCompletionInfo,
2112 NdefMap->psRemoteDevInfo,
2113 NdefMap->Cmd,
2114 &NdefMap->psDepAdditionalInfo,
2115 NdefMap->SendRecvBuf,
2116 NdefMap->SendLength,
2117 NdefMap->SendRecvBuf,
2118 NdefMap->SendRecvLength);
2119 return (status);
2120 }
2121
2122 /*!
2123 * \brief Check whether a particular Remote Device is NDEF compliant.
2124 * The function checks whether the peer device is NDEF compliant.
2125 */
2126
phFriNfc_Felica_ChkNdef(phFriNfc_NdefMap_t * NdefMap)2127 NFCSTATUS phFriNfc_Felica_ChkNdef( phFriNfc_NdefMap_t *NdefMap)
2128 {
2129 NFCSTATUS status = NFCSTATUS_PENDING;
2130 uint8_t sysCode[2];
2131
2132 /* set the system code for selecting the wild card*/
2133 sysCode[0] = 0x12;
2134 sysCode[1] = 0xFC;
2135
2136 status = phFriNfc_Felica_HPollCard( NdefMap,sysCode,PH_NFCFRI_NDEFMAP_FELI_STATE_SELECT_NDEF_APP);
2137
2138 return (status);
2139
2140 }
2141 /*!
2142 * \brief Check whether a particular Remote Device is NDEF compliant.
2143 * selects the sysCode and then NFC Forum Reference Applications
2144 */
2145 #ifdef PH_HAL4_ENABLE
phFriNfc_Felica_HPollCard(phFriNfc_NdefMap_t * NdefMap,const uint8_t sysCode[],uint8_t state)2146 static NFCSTATUS phFriNfc_Felica_HPollCard( phFriNfc_NdefMap_t *NdefMap,
2147 const uint8_t sysCode[],
2148 uint8_t state)
2149 {
2150 NFCSTATUS status = NFCSTATUS_PENDING;
2151
2152 /*Format the Poll Packet for selecting the system code passed as parameter */
2153 NdefMap->SendRecvBuf[0] = 0x06;
2154 NdefMap->SendRecvBuf[1] = 0x00;
2155 NdefMap->SendRecvBuf[2] = sysCode[0];
2156 NdefMap->SendRecvBuf[3] = sysCode[1];
2157 NdefMap->SendRecvBuf[4] = 0x01;
2158 NdefMap->SendRecvBuf[5] = 0x03;
2159
2160 NdefMap->SendLength = 6;
2161
2162 /*set the completion routines for the felica card operations*/
2163 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_Felica_Process;
2164 NdefMap->MapCompletionInfo.Context = NdefMap;
2165
2166 /*Set Ndef State*/
2167 NdefMap->State = state;
2168
2169 /* set the felica cmd */
2170 NdefMap->Cmd.FelCmd = phHal_eFelica_Raw;
2171
2172 /*set the additional informations for the data exchange*/
2173 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
2174 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0;
2175
2176 status = phFriNfc_OvrHal_Transceive(NdefMap->LowerDevice,
2177 &NdefMap->MapCompletionInfo,
2178 NdefMap->psRemoteDevInfo,
2179 NdefMap->Cmd,
2180 &NdefMap->psDepAdditionalInfo,
2181 NdefMap->SendRecvBuf,
2182 NdefMap->SendLength,
2183 NdefMap->SendRecvBuf,
2184 NdefMap->SendRecvLength);
2185 return (status);
2186 }
2187 #endif
2188
2189
2190 #ifndef PH_HAL4_ENABLE
phFriNfc_Felica_HPollCard(phFriNfc_NdefMap_t * NdefMap,const uint8_t sysCode[],uint8_t state)2191 static NFCSTATUS phFriNfc_Felica_HPollCard( phFriNfc_NdefMap_t *NdefMap,
2192 const uint8_t sysCode[],
2193 uint8_t state)
2194 {
2195 NFCSTATUS status = NFCSTATUS_PENDING;
2196
2197 /*Format the Poll Packet for selecting the wild card "0xff 0xff as system code*/
2198 NdefMap->FelicaPollDetails.DevInputParam->FelicaPollPayload[0] = 0x00;
2199 NdefMap->FelicaPollDetails.DevInputParam->FelicaPollPayload[1] = sysCode[0];
2200 NdefMap->FelicaPollDetails.DevInputParam->FelicaPollPayload[2] = sysCode[1];
2201 NdefMap->FelicaPollDetails.DevInputParam->FelicaPollPayload[3] = 0x01;
2202 NdefMap->FelicaPollDetails.DevInputParam->FelicaPollPayload[4] = 0x03;
2203
2204 /* set the length to zero*/
2205 NdefMap->FelicaPollDetails.DevInputParam->GeneralByteLength =0x00;
2206
2207 NdefMap->NoOfDevices = PH_FRINFC_NDEFMAP_FELI_NUM_DEVICE_TO_DETECT;
2208
2209 /*set the completion routines for the felica card operations*/
2210 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_Felica_Process;
2211 NdefMap->MapCompletionInfo.Context = NdefMap;
2212
2213 /*Set Ndef State*/
2214 NdefMap->State = state;
2215
2216 /* Harsha: This is a special case for felica.
2217 Make a copy of the remote device information and send it for
2218 polling. Return the original remote device information to the
2219 caller. The user does not need the updated results of the poll
2220 that we are going to call now. This is only used for checking
2221 whether the felica card is NDEF compliant or not. */
2222 (void) memcpy( &NdefMap->FelicaPollDetails.psTempRemoteDevInfo,
2223 NdefMap->psRemoteDevInfo,
2224 sizeof(phHal_sRemoteDevInformation_t));
2225
2226 /* Reset the session opened flag */
2227 NdefMap->FelicaPollDetails.psTempRemoteDevInfo.SessionOpened = 0x00;
2228
2229 /*Call the Overlapped HAL POLL function */
2230 status = phFriNfc_OvrHal_Poll( NdefMap->LowerDevice,
2231 &NdefMap->MapCompletionInfo,
2232 NdefMap->OpModeType,
2233 &NdefMap->FelicaPollDetails.psTempRemoteDevInfo,
2234 &NdefMap->NoOfDevices,
2235 NdefMap->FelicaPollDetails.DevInputParam);
2236
2237 return (status);
2238 }
2239 #endif /* #ifndef PH_HAL4_ENABLE */
2240 /*!
2241 * \brief Checks validity of system code sent from the lower device, during poll operation.
2242 */
2243
phFriNfc_Felica_HUpdateManufIdDetails(const phFriNfc_NdefMap_t * NdefMap)2244 static NFCSTATUS phFriNfc_Felica_HUpdateManufIdDetails(const phFriNfc_NdefMap_t *NdefMap)
2245 {
2246 NFCSTATUS status = NFCSTATUS_PENDING;
2247
2248 /* Get the details from Poll Response packet */
2249 if (NdefMap->SendRecvLength >= 20)
2250 {
2251 (void)memcpy( (uint8_t *)NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm,
2252 (uint8_t *)&NdefMap->SendRecvBuf[2], 8);
2253 (void)memcpy( (uint8_t *)NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.PMm,
2254 (uint8_t *)&NdefMap->SendRecvBuf[10], 8);
2255 NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.SystemCode[1] = NdefMap->SendRecvBuf[18];
2256 NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.SystemCode[0] = NdefMap->SendRecvBuf[19];
2257 NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDmLength = 8;
2258
2259 /* copy the IDm and PMm in Manufacture Details Structure*/
2260 (void)memcpy( (uint8_t *)(NdefMap->FelicaManufDetails.ManufID),
2261 (uint8_t *)NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm,
2262 8);
2263 (void)memcpy( (uint8_t *)(NdefMap->FelicaManufDetails.ManufParameter),
2264 (uint8_t *)NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.PMm,
2265 8);
2266 if((NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.SystemCode[1] == 0x12)
2267 && (NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.SystemCode[0] == 0xFC))
2268 {
2269 status = PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_SUCCESS);
2270 }
2271 else
2272 {
2273 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2274 NFCSTATUS_NO_NDEF_SUPPORT);
2275 }
2276 }
2277 else
2278 {
2279 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2280 NFCSTATUS_NO_NDEF_SUPPORT);
2281 }
2282
2283 return (status);
2284 }
2285
2286
2287 /*!
2288 * \brief Completion Routine, Processing function, needed to avoid long blocking.
2289 * \note The lower (Overlapped HAL) layer must register a pointer to this function as a Completion
2290 * Routine in order to be able to notify the component that an I/O has finished and data are
2291 * ready to be processed.
2292 */
2293
phFriNfc_Felica_Process(void * Context,NFCSTATUS Status)2294 void phFriNfc_Felica_Process(void *Context,
2295 NFCSTATUS Status)
2296 {
2297 uint8_t CRFlag = FALSE;
2298 uint16_t RecvTxLen = 0,
2299 BytesToRecv = 0,
2300 Nbc = 0;
2301 uint32_t TotNoWrittenBytes = 0,
2302 NDEFLen=0;
2303
2304 /*Set the context to Map Module*/
2305 phFriNfc_NdefMap_t *NdefMap = (phFriNfc_NdefMap_t *)Context;
2306
2307 if ( Status == NFCSTATUS_SUCCESS )
2308 {
2309 switch (NdefMap->State)
2310 {
2311 case PH_NFCFRI_NDEFMAP_FELI_STATE_SELECT_NDEF_APP:
2312
2313 /* check the ndef compliency with the system code reecived in the RemoteDevInfo*/
2314 Status = phFriNfc_Felica_HUpdateManufIdDetails(NdefMap);
2315
2316 if (Status == NFCSTATUS_SUCCESS)
2317 {
2318 /* Mantis ID : 645*/
2319 /* set the operation type to Check ndef type*/
2320 NdefMap->Felica.OpFlag = PH_FRINFC_NDEFMAP_FELI_CHK_NDEF_OP;
2321 Status = phFriNfc_Felica_HRdAttrInfo(NdefMap);
2322 /* handle the error in Transc function*/
2323 if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
2324 {
2325 CRFlag = TRUE;
2326 }
2327 }
2328 else
2329 {
2330 CRFlag = TRUE;
2331 }
2332 if ( CRFlag == TRUE )
2333 {
2334 /* call respective CR */
2335 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_CHK_NDEF,Status);
2336
2337 }
2338 break;
2339
2340 case PH_NFCFRI_NDEFMAP_FELI_STATE_RD_ATTR:
2341 /* check for the status flag1 and status flag2for the successful read operation*/
2342 if ( NdefMap->SendRecvBuf[10] == 0x00)
2343 {
2344 /* check the Manuf Id in the receive buffer*/
2345 Status = phFriNfc_Felica_HCheckManufId(NdefMap);
2346 if ( Status == NFCSTATUS_SUCCESS)
2347 {
2348 /* Update the Attribute Information in to the context structure*/
2349 Status = phFriNfc_Felica_HUpdateAttrInfo(NdefMap);
2350 if ( Status == NFCSTATUS_SUCCESS )
2351 {
2352 PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0],
2353 NdefMap->FelicaAttrInfo.LenBytes[1],
2354 NdefMap->FelicaAttrInfo.LenBytes[2],
2355 NDEFLen);
2356
2357 if ( NdefMap->Felica.OpFlag == PH_FRINFC_NDEFMAP_FELI_WR_ATTR_RD_OP )
2358 {
2359 /* Proceed With Write Functinality*/
2360 Status = phFriNfc_Felica_HChkAttrBlkForWrOp(NdefMap);
2361 /* handle the error in Transc function*/
2362 if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
2363 {
2364 /* call respective CR */
2365 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status);
2366 }
2367 }
2368 else if( NdefMap->Felica.OpFlag == PH_FRINFC_NDEFMAP_FELI_RD_ATTR_RD_OP )
2369 {
2370 /* Proceed With Read Functinality*/
2371 Status = phFriNfc_Felica_HChkAttrBlkForRdOp(NdefMap,NDEFLen);
2372 if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
2373 {
2374 /* call respective CR */
2375 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_RD_NDEF,Status);
2376 }
2377 }
2378 else if( NdefMap->Felica.OpFlag == PH_FRINFC_NDEFMAP_FELI_CHK_NDEF_OP )
2379 {
2380
2381 Status = phFriNfc_MapTool_SetCardState( NdefMap,
2382 NDEFLen);
2383 /* check status value*/
2384 NdefMap->CardType = PH_FRINFC_NDEFMAP_FELICA_SMART_CARD;
2385 /*reset the buffer index*/
2386 NdefMap->ApduBuffIndex = 0;
2387 /* set the Next operation Flag to indicate need of reading attribute information*/
2388 NdefMap->Felica.OpFlag = PH_FRINFC_NDEFMAP_FELI_OP_NONE;
2389 /* call respective CR */
2390 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_CHK_NDEF,Status);
2391 }
2392 else if ( NdefMap->Felica.OpFlag == PH_FRINFC_NDEFMAP_FELI_WR_EMPTY_MSG_OP )
2393 {
2394 /* Proceed With Write Functinality*/
2395 Status = phFriNfc_Felica_HWrEmptyMsg(NdefMap);
2396 /* handle the error in Transc function*/
2397 if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
2398 {
2399 /* call respective CR */
2400 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_ERASE_NDEF,Status);
2401 }
2402 }
2403 else
2404 {
2405
2406 /* invalid operation occured*/
2407 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
2408 NFCSTATUS_INVALID_DEVICE_REQUEST);
2409 CRFlag =TRUE ;
2410 }
2411 }
2412 else
2413 {
2414 CRFlag =TRUE ;
2415 }
2416 }
2417 else
2418 {
2419 CRFlag =TRUE ;
2420 }
2421 }
2422 else
2423 {
2424 CRFlag =TRUE;
2425 /*handle the Error case*/
2426 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
2427 NFCSTATUS_READ_FAILED);
2428 }
2429 if ( CRFlag == TRUE )
2430 {
2431 /* call respective CR */
2432 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_RD_NDEF,Status);
2433 }
2434 break;
2435
2436 case PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_BEGIN:
2437 /* chk the status flags 1 and 2*/
2438 if ( NdefMap->SendRecvBuf[10] == 0x00 )
2439 {
2440 /* Update Data Call*/
2441 Status =phFriNfc_Felica_HUpdateData(NdefMap);
2442 if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
2443 {
2444 /* call respective CR */
2445 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status);
2446 }
2447 }
2448 else
2449 {
2450 /*handle the Error case*/
2451 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
2452 NFCSTATUS_WRITE_FAILED);
2453 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status);
2454
2455 }
2456 break;
2457 case PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_END:
2458
2459 /* chk the status flags 1 and 2*/
2460 if ( NdefMap->SendRecvBuf[10] == 0x00)
2461 {
2462 /* Entire Write Operation is complete*/
2463 Status = PHNFCSTVAL(CID_NFC_NONE,\
2464 NFCSTATUS_SUCCESS);
2465 }
2466 else
2467 {
2468 /*handle the Error case*/
2469 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
2470 NFCSTATUS_WRITE_FAILED);
2471 }
2472 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status);
2473 break;
2474
2475 case PH_NFCFRI_NDEFMAP_FELI_STATE_WR_EMPTY_MSG :
2476
2477 /* chk the status flags 1 and 2*/
2478 if ( NdefMap->SendRecvBuf[10] == 0x00)
2479 {
2480 /* Entire Write Operation is complete*/
2481 Status = PHNFCSTVAL(CID_NFC_NONE,\
2482 NFCSTATUS_SUCCESS);
2483 }
2484 else
2485 {
2486 /*handle the Error case*/
2487 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
2488 NFCSTATUS_WRITE_FAILED);
2489 }
2490 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status);
2491 break;
2492
2493 case PH_NFCFRI_NDEFMAP_FELI_STATE_WR_BLOCK :
2494 if(NdefMap->SendRecvBuf[1] == PH_NFCFRI_NDEFMAP_FELI_WR_RESP_BYTE )
2495 {
2496 /* chk the status flags 1 and 2*/
2497 if ( NdefMap->SendRecvBuf[10] == 0x00 )
2498 {
2499 /* This is used when we have bytes less than 16 bytes*/
2500 if ( NdefMap->Felica.IntermediateWrFlag == TRUE )
2501 {
2502 /* after Successful write copy the last writtened bytes back to the
2503 internal buffer*/
2504 (void)memcpy( (&(NdefMap->Felica.Wr_RemainedBytesBuff[NdefMap->Felica.Wr_BytesRemained])),
2505 NdefMap->ApduBuffer,
2506 NdefMap->NumOfBytesWritten);
2507
2508 NdefMap->Felica.Wr_BytesRemained +=
2509 (uint8_t)( NdefMap->NumOfBytesWritten);
2510
2511 /* Increment the Send Buffer index */
2512 NdefMap->ApduBuffIndex +=
2513 NdefMap->NumOfBytesWritten;
2514
2515 *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex;
2516 NdefMap->Felica.IntermediateWrFlag = FALSE;
2517 /* Call Update Data()*/
2518 Status = phFriNfc_Felica_HUpdateData(NdefMap);
2519 }
2520 else
2521 {
2522 /* update the index and bytes writtened*/
2523 NdefMap->ApduBuffIndex += NdefMap->NumOfBytesWritten;
2524 *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex;
2525 if ( NdefMap->Felica.EofCardReachedFlag )
2526 {
2527 if ( NdefMap->Felica.CurBlockNo < NdefMap->FelicaAttrInfo.Nmaxb)
2528 {
2529 NdefMap->Felica.CurBlockNo += NdefMap->Felica.NoBlocksWritten;
2530 }
2531 if (( NdefMap->Felica.CurBlockNo == NdefMap->FelicaAttrInfo.Nmaxb) &&
2532 ( NdefMap->ApduBuffIndex == (NdefMap->FelicaAttrInfo.Nmaxb*16)))
2533 {
2534 NdefMap->Felica.EofCardReachedFlag = FELICA_RD_WR_EOF_CARD_REACHED ;
2535 /*0 represents the write ended*/
2536 Status = phFriNfc_Felica_HUpdateAttrBlkForWrOp(NdefMap,FELICA_WRITE_ENDED);
2537 if( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
2538 {
2539 /* call respective CR */
2540 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status);
2541 }
2542 }
2543 else
2544 {
2545 PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0],
2546 NdefMap->FelicaAttrInfo.LenBytes[1],
2547 NdefMap->FelicaAttrInfo.LenBytes[2],
2548 TotNoWrittenBytes);
2549 if ( ( NdefMap->Felica.CurBlockNo == NdefMap->FelicaAttrInfo.Nmaxb) &&
2550 ((TotNoWrittenBytes + NdefMap->ApduBuffIndex) == (uint32_t)(NdefMap->FelicaAttrInfo.Nmaxb*16)))
2551 {
2552 NdefMap->Felica.EofCardReachedFlag =FELICA_RD_WR_EOF_CARD_REACHED;
2553 /*0 represents the write ended*/
2554 Status = phFriNfc_Felica_HUpdateAttrBlkForWrOp(NdefMap,FELICA_WRITE_ENDED);
2555 if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
2556 {
2557 /* call respective CR */
2558 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status);
2559 }
2560 }
2561 else
2562 {
2563 /* Call Update Data()*/
2564 Status = phFriNfc_Felica_HUpdateData(NdefMap);
2565 if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
2566 {
2567 /* call respective CR */
2568 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status);
2569 }
2570 }
2571 }
2572 }/*if ( NdefMap->Felica.EofCardReachedFlag )*/
2573 else
2574 {
2575 NdefMap->Felica.CurBlockNo += NdefMap->Felica.NoBlocksWritten;
2576 /* Call Update Data()*/
2577 Status = phFriNfc_Felica_HUpdateData(NdefMap);
2578 if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
2579 {
2580 /* call respective CR */
2581 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status);
2582 }
2583 }
2584 }
2585 }/*if ( NdefMap->SendRecvBuf[10] == 0x00 )*/
2586 else
2587 {
2588 /*handle the Error case*/
2589 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
2590 NFCSTATUS_WRITE_FAILED);
2591 CRFlag = TRUE;
2592
2593 }
2594 }/*if(NdefMap->SendRecvBuf[1] == PH_NFCFRI_NDEFMAP_FELI_WR_RESP_BYTE )*/
2595 else
2596 {
2597 /*return Error "Invalid Write Response Code"*/
2598 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2599 NFCSTATUS_WRITE_FAILED);
2600 CRFlag = TRUE;
2601
2602 }
2603 if ( CRFlag == TRUE )
2604 {
2605 /* Reset following parameters*/
2606 NdefMap->ApduBuffIndex=0;
2607 NdefMap->Felica.Wr_BytesRemained = 0;
2608 NdefMap->ApduBufferSize = 0;
2609 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status);
2610 }
2611
2612 break;
2613
2614 case PH_NFCFRI_NDEFMAP_FELI_STATE_RD_BLOCK :
2615
2616 /* check the Manuf Id in the receive buffer*/
2617 Status = phFriNfc_Felica_HCheckManufId(NdefMap);
2618 if ( Status == NFCSTATUS_SUCCESS )
2619 {
2620 if(NdefMap->SendRecvBuf[1] == PH_NFCFRI_NDEFMAP_FELI_RD_RESP_BYTE )
2621 {
2622 /* calculate the Nmaxb*/
2623 Nbc = phFriNfc_Felica_HGetMaximumBlksToRead(NdefMap,PH_NFCFRI_NDEFMAP_FELI_NBC);
2624 /*get Receive length from the card for corss verifications*/
2625 RecvTxLen= phFriNfc_Felica_HSetTrxLen(NdefMap,Nbc);
2626 BytesToRecv = NdefMap->SendRecvBuf[12]*16;
2627
2628 /* chk the status flags 1 */
2629 if ( NdefMap->SendRecvBuf[10] == 0x00)
2630 {
2631 if ( RecvTxLen == BytesToRecv)
2632 {
2633 NdefMap->Felica.CurBlockNo += (uint8_t)(RecvTxLen/16);
2634 phFriNfc_Felica_HAfterRead_CopyDataToBuff(NdefMap);
2635 Status = phFriNfc_Felica_HReadData(NdefMap,PH_FRINFC_NDEFMAP_SEEK_CUR);
2636 /* handle the error in Transc function*/
2637 if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER))
2638 {
2639 CRFlag =TRUE;
2640 }
2641 }
2642 else
2643 {
2644 CRFlag =TRUE;
2645 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2646 NFCSTATUS_INVALID_RECEIVE_LENGTH);
2647 /*set the buffer index back to zero*/
2648 NdefMap->ApduBuffIndex = 0;
2649 NdefMap->Felica.Rd_NoBytesToCopy = 0;
2650 }
2651 }
2652 else
2653 {
2654 NdefMap->ApduBuffIndex=0;
2655 /*handle the Error case*/
2656 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\
2657 NFCSTATUS_READ_FAILED);
2658 CRFlag =TRUE;
2659 }
2660 }
2661 else
2662 {
2663 CRFlag =TRUE;
2664 NdefMap->ApduBuffIndex=0;
2665 /*return Error "Invalid Read Response Code"*/
2666 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2667 NFCSTATUS_READ_FAILED);
2668 }
2669 }
2670 else
2671 {
2672 CRFlag =TRUE;
2673 }
2674 if ( CRFlag ==TRUE )
2675 {
2676 /* call respective CR */
2677 phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_RD_NDEF,Status);
2678 }
2679 break;
2680
2681 default:
2682 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2683 NFCSTATUS_INVALID_DEVICE_REQUEST);
2684 phFriNfc_Felica_HCrHandler(NdefMap, PH_FRINFC_NDEFMAP_CR_INVALID_OPE, Status);
2685 break;
2686
2687
2688 }
2689 }
2690 else
2691 {
2692 /* Call CR for unknown Error's*/
2693 switch ( NdefMap->State)
2694 {
2695 case PH_FRINFC_NDEFMAP_FELI_STATE_CHK_NDEF :
2696 case PH_NFCFRI_NDEFMAP_FELI_STATE_SELECT_WILD_CARD :
2697 case PH_NFCFRI_NDEFMAP_FELI_STATE_SELECT_NDEF_APP :
2698 case PH_NFCFRI_NDEFMAP_FELI_STATE_RD_ATTR :
2699 phFriNfc_Felica_HCrHandler(NdefMap, PH_FRINFC_NDEFMAP_CR_CHK_NDEF,
2700 Status);
2701 break;
2702 case PH_NFCFRI_NDEFMAP_FELI_STATE_WR_BLOCK :
2703 case PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_BEGIN :
2704 case PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_END :
2705 phFriNfc_Felica_HCrHandler(NdefMap, PH_FRINFC_NDEFMAP_CR_WR_NDEF,
2706 Status);
2707 break;
2708 case PH_NFCFRI_NDEFMAP_FELI_STATE_RD_BLOCK :
2709 phFriNfc_Felica_HCrHandler(NdefMap, PH_FRINFC_NDEFMAP_CR_RD_NDEF,
2710 Status);
2711 break;
2712 default :
2713 /*set the invalid state*/
2714 Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST);
2715 phFriNfc_Felica_HCrHandler(NdefMap, PH_FRINFC_NDEFMAP_CR_INVALID_OPE, Status);
2716 break;
2717 }
2718 }
2719
2720 }
2721
2722 /*!
2723 * \brief Prepares Cmd Pkt for reading attribute Blk information.
2724 */
phFriNfc_Felica_HRdAttrInfo(phFriNfc_NdefMap_t * NdefMap)2725 static NFCSTATUS phFriNfc_Felica_HRdAttrInfo(phFriNfc_NdefMap_t *NdefMap)
2726 {
2727
2728 NFCSTATUS status = NFCSTATUS_PENDING;
2729 uint8_t BufIndex = 0;
2730
2731 /* Set the Felica Cmd*/
2732 #ifdef PH_HAL4_ENABLE
2733 NdefMap->Cmd.FelCmd = phHal_eFelica_Raw;
2734 #else
2735 NdefMap->Cmd.FelCmd = phHal_eFelicaCmdListFelicaCmd;
2736 #endif /* #ifdef PH_HAL4_ENABLE */
2737
2738 /*set the additional informations for the data exchange*/
2739 NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
2740 NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0;
2741
2742 /* 1st byte represents the length of the cmd packet*/
2743 NdefMap->SendRecvBuf[BufIndex] = 0x00;
2744 BufIndex++;
2745
2746 /* Read/check command code*/
2747 NdefMap->SendRecvBuf[BufIndex] = 0x06;
2748 BufIndex++;
2749
2750 /* IDm - Manufacturer Id : 8bytes*/
2751 #ifdef PH_HAL4_ENABLE
2752 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
2753 (void * )&NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm,
2754 8);
2755 #else
2756 (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])),
2757 (void * )&NdefMap->psRemoteDevInfo->RemoteDevInfo.CardInfo212_424.Startup212_424.NFCID2t,
2758 8);
2759
2760 #endif /* #ifdef PH_HAL4_ENABLE */
2761
2762 BufIndex+=8;
2763
2764 NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Services (n=1 ==> 0x80)*/
2765 BufIndex++;
2766
2767 NdefMap->SendRecvBuf[BufIndex] = 0x0B; /* Service Code List*/
2768 BufIndex++;
2769
2770 NdefMap->SendRecvBuf[BufIndex] = 0x00; /* Service Code List*/
2771 BufIndex++;
2772
2773 NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Blocks to read)*/
2774 BufIndex++;
2775
2776 NdefMap->SendRecvBuf[BufIndex] = 0x80; /* 1st Block Element : byte 1*/
2777 BufIndex++;
2778
2779 NdefMap->SendRecvBuf[BufIndex] = 0x00; /* 1st Block Element : byte 2, block 1*/
2780 BufIndex++;
2781
2782 NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex;
2783
2784 *NdefMap->SendRecvLength = NdefMap->TempReceiveLength;
2785
2786 /* Update the Send Len*/
2787 NdefMap->SendLength = BufIndex;
2788
2789 /* Change the state to PH_NFCFRI_NDEFMAP_FELI_STATE_RD_ATTR */
2790 NdefMap->State = PH_NFCFRI_NDEFMAP_FELI_STATE_RD_ATTR;
2791
2792 /*set the completion routines for the desfire card operations*/
2793 NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_NdefMap_Process;
2794 NdefMap->MapCompletionInfo.Context = NdefMap;
2795
2796 /*Call the Overlapped HAL Transceive function */
2797 status = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice,
2798 &NdefMap->MapCompletionInfo,
2799 NdefMap->psRemoteDevInfo,
2800 NdefMap->Cmd,
2801 &NdefMap->psDepAdditionalInfo,
2802 NdefMap->SendRecvBuf,
2803 NdefMap->SendLength,
2804 NdefMap->SendRecvBuf,
2805 NdefMap->SendRecvLength);
2806 return (status);
2807
2808 }
2809
2810 /*!
2811 * \brief Validated manufacturer Details, during the read/write operations.
2812 */
2813
phFriNfc_Felica_HCheckManufId(const phFriNfc_NdefMap_t * NdefMap)2814 static NFCSTATUS phFriNfc_Felica_HCheckManufId(const phFriNfc_NdefMap_t *NdefMap)
2815 {
2816 NFCSTATUS status = NFCSTATUS_PENDING;
2817
2818 uint8_t result = 0;
2819
2820 /* check the stored manufacture id with the received manufacture id*/
2821 result = (uint8_t)(phFriNfc_Felica_MemCompare( (void *)(&(NdefMap->SendRecvBuf[2])),
2822 (void *)NdefMap->FelicaManufDetails.ManufID,
2823 8));
2824
2825 if ( result != 0)
2826 {
2827 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_REMOTE_DEVICE);
2828
2829 }
2830 else
2831 {
2832 status = PHNFCSTVAL(CID_NFC_NONE,NFCSTATUS_SUCCESS);
2833
2834 }
2835 return (status);
2836 }
2837
phFriNfc_Felica_HCalCheckSum(const uint8_t * TempBuffer,uint8_t StartIndex,uint8_t EndIndex,uint16_t RecvChkSum)2838 static NFCSTATUS phFriNfc_Felica_HCalCheckSum(const uint8_t *TempBuffer,
2839 uint8_t StartIndex,
2840 uint8_t EndIndex,
2841 uint16_t RecvChkSum)
2842 {
2843 NFCSTATUS Result = NFCSTATUS_SUCCESS;
2844 uint16_t CheckSum=0,
2845 BufIndex=0;
2846
2847 for(BufIndex = StartIndex;BufIndex <=EndIndex;BufIndex++)
2848 {
2849 CheckSum += TempBuffer[BufIndex];
2850 }
2851 if( RecvChkSum != CheckSum )
2852 {
2853 Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,
2854 NFCSTATUS_INVALID_FORMAT);
2855 }
2856 return (Result);
2857 }
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869 /*!
2870 * \brief On successful read attribute blk information, this function validates and stores the
2871 * Attribute informations in to the context.
2872 */
phFriNfc_Felica_HUpdateAttrInfo(phFriNfc_NdefMap_t * NdefMap)2873 static NFCSTATUS phFriNfc_Felica_HUpdateAttrInfo(phFriNfc_NdefMap_t *NdefMap)
2874 {
2875 NFCSTATUS status = NFCSTATUS_PENDING;
2876 uint8_t CRFlag = FALSE,
2877 Nmaxb1, Nmaxb2 = 0,
2878 ChkSum1 = 0, ChkSum2=0;
2879
2880 uint16_t Nmaxblk = 0,
2881 RecvChkSum=0,
2882 NdefBlk = 0;
2883 uint32_t DataLen =0;
2884
2885
2886 /* Validate T3VNo and NFCDevVNo */
2887 status = phFriNfc_MapTool_ChkSpcVer(NdefMap,
2888 PH_NFCFRI_NDEFMAP_FELI_VERSION_INDEX);
2889 if ( status != NFCSTATUS_SUCCESS )
2890 {
2891 CRFlag = TRUE;
2892 }
2893 else
2894 {
2895 /* get the Nmaxb from the receive buffer*/
2896 Nmaxb1 = NdefMap->SendRecvBuf[16];
2897 Nmaxb2 = NdefMap->SendRecvBuf[17];
2898
2899 Nmaxblk = (((uint16_t)Nmaxb1 << 8) | (Nmaxb2 & 0x00ff));
2900
2901 if ( Nmaxblk != 0 )
2902 {
2903 /* check the Nbr against the Nmaxb*/
2904 if ( NdefMap->SendRecvBuf[14] > Nmaxblk )
2905 {
2906 CRFlag = TRUE;
2907 }
2908 else
2909 {
2910 /*check Nbw > Nmaxb*/
2911 /*check the write flag validity*/
2912 /*check for the RFU bytes validity*/
2913 if ( (NdefMap->SendRecvBuf[15] > Nmaxblk) ||
2914 ((NdefMap->SendRecvBuf[22] != 0x00) && (NdefMap->SendRecvBuf[22] !=0x0f ))||
2915 ( (NdefMap->SendRecvBuf[23] != 0x00) && (NdefMap->SendRecvBuf[23] !=0x01 ))||
2916 ( NdefMap->SendRecvBuf[18] != 0x00) ||
2917 ( NdefMap->SendRecvBuf[19] != 0x00) ||
2918 ( NdefMap->SendRecvBuf[20] != 0x00) ||
2919 ( NdefMap->SendRecvBuf[21] != 0x00))
2920
2921 {
2922 CRFlag = TRUE;
2923 }
2924 else
2925 {
2926 /* check the validity of the actual ndef data len*/
2927 PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES( NdefMap->SendRecvBuf[24],
2928 NdefMap->SendRecvBuf[25],
2929 NdefMap->SendRecvBuf[26],
2930 DataLen);
2931
2932
2933 /* Calculate Nbc*/
2934 NdefBlk = (uint16_t )((( DataLen % 16) == 0 ) ? (DataLen >> 4) : ((DataLen >> 4) +1));
2935
2936 /* check Nbc against Nmaxb*/
2937 if ((NdefBlk > Nmaxblk))
2938 {
2939 CRFlag = TRUE;
2940 }
2941 else
2942 {
2943 /*Store the attribute information in phFriNfc_Felica_AttrInfo*/
2944 NdefMap->FelicaAttrInfo.Version = NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_VERSION_INDEX];
2945 NdefMap->FelicaAttrInfo.Nbr = NdefMap->SendRecvBuf[14];
2946 NdefMap->FelicaAttrInfo.Nbw = NdefMap->SendRecvBuf[15];
2947
2948 NdefMap->FelicaAttrInfo.Nmaxb = Nmaxblk;
2949
2950 NdefMap->FelicaAttrInfo.WriteFlag = NdefMap->SendRecvBuf[22];
2951 NdefMap->FelicaAttrInfo.RdWrFlag = NdefMap->SendRecvBuf[23];
2952
2953 /* Get CheckSum*/
2954 ChkSum1 = NdefMap->SendRecvBuf[27];
2955 ChkSum2 = NdefMap->SendRecvBuf[28];
2956
2957 RecvChkSum = (((uint16_t)ChkSum1 << 8) | (ChkSum2 & 0x00ff));
2958
2959 /* Check the check sum validity?*/
2960 status = phFriNfc_Felica_HCalCheckSum(NdefMap->SendRecvBuf,
2961 PH_NFCFRI_NDEFMAP_FELI_VERSION_INDEX,
2962 26,
2963 RecvChkSum);
2964 if ( status != NFCSTATUS_SUCCESS )
2965 {
2966 CRFlag = TRUE;
2967 }
2968 else
2969 {
2970 /*check RW Flag Access Rights*/
2971 /* set to read only cannot write*/
2972 if ( NdefMap->FelicaAttrInfo.RdWrFlag == 0x00 )
2973 {
2974 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY;
2975 }
2976 else if ( NdefMap->FelicaAttrInfo.RdWrFlag == 0x01 ) // additional check for R/W access
2977 {
2978 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_WRITE;
2979 }
2980 else // otherwise invalid
2981 {
2982 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
2983 }
2984
2985 NdefMap->FelicaAttrInfo.LenBytes[0] = NdefMap->SendRecvBuf[24];
2986 NdefMap->FelicaAttrInfo.LenBytes[1] = NdefMap->SendRecvBuf[25];
2987 NdefMap->FelicaAttrInfo.LenBytes[2] = NdefMap->SendRecvBuf[26];
2988 status = PHNFCSTVAL(CID_NFC_NONE,NFCSTATUS_SUCCESS);
2989 }
2990 }
2991 }
2992 }
2993 }
2994 else
2995 {
2996 CRFlag = TRUE;
2997 }
2998 }
2999 if ( (status == NFCSTATUS_INVALID_FORMAT ) && (CRFlag == TRUE ))
3000 {
3001 NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID;
3002 }
3003 if ( CRFlag == TRUE )
3004 {
3005 /*Return Status Error � Invalid Format�*/
3006 status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,NFCSTATUS_INVALID_FORMAT);
3007 }
3008
3009 return (status);
3010 }
3011
3012 /*!
3013 * \brief this shall notify the integration software with respective
3014 * success/error status along with the completion routines.
3015 */
phFriNfc_Felica_HCrHandler(phFriNfc_NdefMap_t * NdefMap,uint8_t CrIndex,NFCSTATUS Status)3016 static void phFriNfc_Felica_HCrHandler(phFriNfc_NdefMap_t *NdefMap,
3017 uint8_t CrIndex,
3018 NFCSTATUS Status)
3019 {
3020 /* set the state back to the Reset_Init state*/
3021 NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RESET_INIT;
3022
3023 /* set the completion routine*/
3024 NdefMap->CompletionRoutine[CrIndex].
3025 CompletionRoutine(NdefMap->CompletionRoutine->Context, Status);
3026 }
3027
3028 /*!
3029 * \brief this shall initialise the internal buffer data to zero.
3030 */
phFriNfc_Felica_HInitInternalBuf(uint8_t * Buffer)3031 static void phFriNfc_Felica_HInitInternalBuf(uint8_t *Buffer)
3032 {
3033 uint8_t index=0;
3034
3035 for( index = 0; index< 16 ; index++)
3036 {
3037 Buffer[index] = 0;
3038 }
3039 }
3040
phFriNfc_Felica_MemCompare(void * s1,void * s2,unsigned int n)3041 static int phFriNfc_Felica_MemCompare ( void *s1, void *s2, unsigned int n )
3042 {
3043 int8_t diff = 0;
3044 int8_t *char_1 =(int8_t *)s1;
3045 int8_t *char_2 =(int8_t *)s2;
3046 if(NULL == s1 || NULL == s2)
3047 {
3048 PHDBG_CRITICAL_ERROR("NULL pointer passed to memcompare");
3049 }
3050 else
3051 {
3052 for(;((n>0)&&(diff==0));n--,char_1++,char_2++)
3053 {
3054 diff = *char_1 - *char_2;
3055 }
3056 }
3057 return (int)diff;
3058 }
3059
3060
3061 #ifdef UNIT_TEST
3062 #include <phUnitTestNfc_Felica_static.c>
3063 #endif
3064
3065 #endif /* PH_FRINFC_MAP_FELICA_DISABLED */
3066