1/*
2 * Copyright (C) 2015 The Android Open Source Project
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#include <nfc_api.h>
18#include <rw_api.h>
19#include <phNfcCompId.h>
20#include <phNxpLog.h>
21#include <phNxpExtns_MifareStd.h>
22
23phNxpExtns_Context_t       gphNxpExtns_Context;
24phNciNfc_TransceiveInfo_t  tNciTranscvInfo;
25phFriNfc_sNdefSmtCrdFmt_t  *NdefSmtCrdFmt = NULL;
26phFriNfc_NdefMap_t         *NdefMap = NULL;
27phLibNfc_NdefInfo_t        NdefInfo;
28#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
29pthread_mutex_t SharedDataMutex = PTHREAD_MUTEX_INITIALIZER;
30#endif
31UINT8 current_key[6]={0};
32phNci_mfc_auth_cmd_t       gAuthCmdBuf;
33STATIC NFCSTATUS phNciNfc_SendMfReq(phNciNfc_TransceiveInfo_t tTranscvInfo,
34                                    uint8_t *buff, uint16_t *buffSz);
35STATIC NFCSTATUS phLibNfc_SendRawCmd(phNfc_sTransceiveInfo_t*    pTransceiveInfo,
36                                    pphNciNfc_TransceiveInfo_t   pMappedTranscvIf);
37STATIC NFCSTATUS phLibNfc_SendWrt16Cmd(phNfc_sTransceiveInfo_t*    pTransceiveInfo,
38                                    pphNciNfc_TransceiveInfo_t   pMappedTranscvIf);
39STATIC NFCSTATUS phLibNfc_SendAuthCmd(phNfc_sTransceiveInfo_t *pTransceiveInfo,
40                                      phNciNfc_TransceiveInfo_t  *tNciTranscvInfo) __attribute__((unused));
41STATIC NFCSTATUS phLibNfc_MapCmds(phNciNfc_RFDevType_t         RemDevType,
42                                    phNfc_sTransceiveInfo_t*  pTransceiveInfo,
43                                    pphNciNfc_TransceiveInfo_t   pMappedTranscvIf);
44STATIC NFCSTATUS phLibNfc_MifareMap(phNfc_sTransceiveInfo_t*    pTransceiveInfo,
45                                    pphNciNfc_TransceiveInfo_t   pMappedTranscvIf);
46STATIC NFCSTATUS phLibNfc_ChkAuthCmdMFC(phNfc_sTransceiveInfo_t* pTransceiveInfo,
47                                    uint8_t *bKey);
48STATIC NFCSTATUS phLibNfc_GetKeyNumberMFC(uint8_t *buffer,uint8_t *bKey);
49STATIC void phLibNfc_CalSectorAddress(uint8_t *Sector_Address);
50STATIC NFCSTATUS  phNciNfc_MfCreateAuthCmdHdr(phNciNfc_TransceiveInfo_t tTranscvInfo,
51                                    uint8_t    bBlockAddr,
52                                    uint8_t    *buff,
53                                    uint16_t    *buffSz);
54STATIC NFCSTATUS phNciNfc_MfCreateXchgDataHdr(phNciNfc_TransceiveInfo_t tTranscvInfo,
55                                    uint8_t *buff, uint16_t *buffSz);
56STATIC NFCSTATUS phLibNfc_SendWrt16CmdPayload(phNfc_sTransceiveInfo_t*    pTransceiveInfo,
57                                    pphNciNfc_TransceiveInfo_t   pMappedTranscvIf);
58STATIC NFCSTATUS phNciNfc_RecvMfResp(phNciNfc_Buff_t* RspBuffInfo, NFCSTATUS wStatus);
59STATIC NFCSTATUS nativeNfcExtns_doTransceive(uint8_t *buff, uint16_t buffSz);
60STATIC NFCSTATUS phFriNfc_NdefSmtCrd_Reset__(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt,
61                                    uint8_t    *SendRecvBuffer,
62                                    uint16_t   *SendRecvBuffLen);
63STATIC NFCSTATUS phFriNfc_ValidateParams(uint8_t  *PacketData,
64                                    uint32_t   *PacketDataLength,
65                                    uint8_t     Offset,
66                                    phFriNfc_NdefMap_t  *pNdefMap,
67                                    uint8_t     bNdefReq);
68STATIC void Mfc_FormatNdef_Completion_Routine(void *NdefCtxt, NFCSTATUS status);
69STATIC void Mfc_WriteNdef_Completion_Routine(void *NdefCtxt, NFCSTATUS status);
70STATIC void Mfc_ReadNdef_Completion_Routine(void *NdefCtxt, NFCSTATUS status);
71STATIC void Mfc_CheckNdef_Completion_Routine(void *NdefCtxt, NFCSTATUS status);
72
73/*******************************************************************************
74**
75** Function         phNxpExtns_MfcModuleDeInit
76**
77** Description      It Deinitializes the Mifare module.
78**
79**                  Frees all the memory occupied by Mifare module
80**
81** Returns:
82**                  NFCSTATUS_SUCCESS - if successfully deinitialize
83**                  NFCSTATUS_FAILED  - otherwise
84**
85*******************************************************************************/
86NFCSTATUS phNxpExtns_MfcModuleDeInit(void)
87{
88    NFCSTATUS status = NFCSTATUS_FAILED;
89
90    if(NdefMap != NULL)
91    {
92        if( NdefMap->psRemoteDevInfo != NULL )
93        {
94            free(NdefMap->psRemoteDevInfo);
95            NdefMap->psRemoteDevInfo = NULL;
96        }
97        if( NdefMap->SendRecvBuf != NULL )
98        {
99            free(NdefMap->SendRecvBuf);
100            NdefMap->SendRecvBuf = NULL;
101        }
102        if( NdefMap->SendRecvLength != NULL )
103        {
104            free(NdefMap->SendRecvLength);
105            NdefMap->SendRecvLength = NULL;
106        }
107        if( NdefMap->DataCount != NULL )
108        {
109            free(NdefMap->DataCount);
110            NdefMap->DataCount = NULL;
111        }
112        if( NdefMap->pTransceiveInfo != NULL )
113        {
114            if( NdefMap->pTransceiveInfo->sSendData.buffer != NULL )
115            {
116                free(NdefMap->pTransceiveInfo->sSendData.buffer);
117                NdefMap->pTransceiveInfo->sSendData.buffer = NULL;
118            }
119            if( NdefMap->pTransceiveInfo->sRecvData.buffer != NULL )
120            {
121                free(NdefMap->pTransceiveInfo->sRecvData.buffer);
122                NdefMap->pTransceiveInfo->sRecvData.buffer = NULL;
123            }
124            free(NdefMap->pTransceiveInfo);
125            NdefMap->pTransceiveInfo = NULL;
126        }
127
128        free(NdefMap);
129        NdefMap = NULL;
130    }
131
132    if( tNciTranscvInfo.tSendData.pBuff != NULL )
133    {
134        free(tNciTranscvInfo.tSendData.pBuff);
135        tNciTranscvInfo.tSendData.pBuff = NULL;
136    }
137
138    if( NdefSmtCrdFmt != NULL )
139    {
140        free(NdefSmtCrdFmt);
141        NdefSmtCrdFmt = NULL;
142    }
143#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
144    pthread_mutex_lock(&SharedDataMutex);
145#endif
146    if ( NULL != NdefInfo.psUpperNdefMsg )
147    {
148        if ( NdefInfo.psUpperNdefMsg->buffer != NULL )
149        {
150            free(NdefInfo.psUpperNdefMsg->buffer);
151            NdefInfo.psUpperNdefMsg->buffer = NULL;
152        }
153        free(NdefInfo.psUpperNdefMsg);
154        NdefInfo.psUpperNdefMsg = NULL;
155    }
156#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
157    pthread_mutex_unlock(&SharedDataMutex);
158#endif
159    if (NULL != gAuthCmdBuf.pauth_cmd)
160    {
161        if (NULL != gAuthCmdBuf.pauth_cmd->buffer)
162        {
163            free(gAuthCmdBuf.pauth_cmd->buffer);
164            gAuthCmdBuf.pauth_cmd->buffer = NULL;
165        }
166        free(gAuthCmdBuf.pauth_cmd);
167        gAuthCmdBuf.pauth_cmd = NULL;
168    }
169    status = NFCSTATUS_SUCCESS;
170    return status;
171}
172
173/*******************************************************************************
174**
175** Function         phNxpExtns_MfcModuleInit
176**
177** Description      It Initializes the memroy and global variables related
178**                  to Mifare module.
179**
180**                  Reset all the global variables and allocate memory for Mifare module
181**
182** Returns:
183**                  NFCSTATUS_SUCCESS - if successfully deinitialize
184**                  NFCSTATUS_FAILED  - otherwise
185**
186*******************************************************************************/
187NFCSTATUS phNxpExtns_MfcModuleInit(void)
188{
189    NFCSTATUS status = NFCSTATUS_FAILED;
190    gphNxpExtns_Context.writecmdFlag = FALSE;
191    gphNxpExtns_Context.RawWriteCallBack = FALSE;
192    gphNxpExtns_Context.CallBackCtxt   = NULL;
193    gphNxpExtns_Context.CallBackMifare = NULL;
194    gphNxpExtns_Context.ExtnsConnect = FALSE;
195    gphNxpExtns_Context.ExtnsDeactivate = FALSE;
196    gphNxpExtns_Context.ExtnsCallBack = FALSE;
197
198    NdefMap = malloc(sizeof(phFriNfc_NdefMap_t));
199    if( NULL == NdefMap )
200    {
201        goto clean_and_return;
202    }
203    memset(NdefMap,0,sizeof(phFriNfc_NdefMap_t));
204
205    NdefMap->psRemoteDevInfo = malloc(sizeof(phLibNfc_sRemoteDevInformation_t));
206    if( NULL == NdefMap->psRemoteDevInfo )
207    {
208        goto clean_and_return;
209    }
210    memset(NdefMap->psRemoteDevInfo, 0, sizeof(phLibNfc_sRemoteDevInformation_t));
211
212    NdefMap->SendRecvBuf = malloc((uint32_t)(MAX_BUFF_SIZE * 2));
213    if( NULL == NdefMap->SendRecvBuf )
214    {
215        goto clean_and_return;
216    }
217    memset(NdefMap->SendRecvBuf, 0, (MAX_BUFF_SIZE * 2));
218
219    NdefMap->SendRecvLength  = malloc(sizeof(uint16_t));
220    if( NULL ==  NdefMap->SendRecvLength )
221    {
222        goto clean_and_return;
223    }
224    memset(NdefMap->SendRecvLength, 0, sizeof(uint16_t));
225
226    NdefMap->DataCount = malloc(sizeof(uint16_t));
227    if( NULL == NdefMap->DataCount )
228    {
229        goto clean_and_return;
230    }
231    memset(NdefMap->DataCount, 0, sizeof(uint16_t));
232
233    NdefMap->pTransceiveInfo = malloc(sizeof(phNfc_sTransceiveInfo_t));
234    if(NULL == NdefMap->pTransceiveInfo)
235    {
236        goto clean_and_return;
237    }
238    memset(NdefMap->pTransceiveInfo, 0, sizeof(phNfc_sTransceiveInfo_t));
239
240    tNciTranscvInfo.tSendData.pBuff = (uint8_t *)malloc((uint32_t)MAX_BUFF_SIZE);
241    if(NULL == tNciTranscvInfo.tSendData.pBuff)
242    {
243        goto clean_and_return;
244    }
245    memset(tNciTranscvInfo.tSendData.pBuff, 0, MAX_BUFF_SIZE);
246
247    NdefMap->pTransceiveInfo->sSendData.buffer = (uint8_t *)malloc((uint32_t)MAX_BUFF_SIZE);
248    if( NdefMap->pTransceiveInfo->sSendData.buffer == NULL )
249    {
250        goto clean_and_return;
251    }
252    memset( NdefMap->pTransceiveInfo->sSendData.buffer, 0, MAX_BUFF_SIZE );
253    NdefMap->pTransceiveInfo->sSendData.length = MAX_BUFF_SIZE;
254
255    NdefMap->pTransceiveInfo->sRecvData.buffer = (uint8_t *)malloc((uint32_t)MAX_BUFF_SIZE); /* size should be same as sRecvData */
256    if( NdefMap->pTransceiveInfo->sRecvData.buffer == NULL )
257    {
258        goto clean_and_return;
259    }
260    memset( NdefMap->pTransceiveInfo->sRecvData.buffer, 0, MAX_BUFF_SIZE );
261    NdefMap->pTransceiveInfo->sRecvData.length = MAX_BUFF_SIZE;
262
263    NdefSmtCrdFmt = malloc( sizeof(phFriNfc_sNdefSmtCrdFmt_t) );
264    if( NdefSmtCrdFmt == NULL )
265    {
266        goto clean_and_return;
267    }
268    memset( NdefSmtCrdFmt , 0, sizeof(phFriNfc_sNdefSmtCrdFmt_t) );
269#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
270    pthread_mutex_lock(&SharedDataMutex);
271#endif
272    NdefInfo.psUpperNdefMsg = malloc(sizeof(phNfc_sData_t));
273    if ( NULL == NdefInfo.psUpperNdefMsg )
274    {
275        goto clean_and_return;
276    }
277    memset( NdefInfo.psUpperNdefMsg, 0, sizeof(phNfc_sData_t) );
278    memset (&gAuthCmdBuf, 0, sizeof(phNci_mfc_auth_cmd_t));
279    gAuthCmdBuf.pauth_cmd = malloc(sizeof(phNfc_sData_t));
280    if (NULL == gAuthCmdBuf.pauth_cmd)
281    {
282        goto clean_and_return;
283    }
284    gAuthCmdBuf.pauth_cmd->buffer = malloc((uint32_t)NCI_MAX_DATA_LEN);
285    if (NULL == gAuthCmdBuf.pauth_cmd->buffer)
286    {
287        goto clean_and_return;
288    }
289    status = NFCSTATUS_SUCCESS;
290
291clean_and_return:
292#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
293    pthread_mutex_unlock(&SharedDataMutex);
294#endif
295    if(status != NFCSTATUS_SUCCESS)
296    {
297        NXPLOG_EXTNS_E("CRIT: Memory Allocation failed for MFC!");
298        phNxpExtns_MfcModuleDeInit();
299    }
300    return status;
301}
302
303/*******************************************************************************
304**
305** Function         Mfc_CheckNdef
306**
307** Description      It triggers NDEF detection for Mifare Classic Tag.
308**
309**
310** Returns          NFCSTATUS_SUCCESS - if successfully initiated
311**                  NFCSTATUS_FAILED  - otherwise
312**
313*******************************************************************************/
314NFCSTATUS Mfc_CheckNdef(void)
315{
316    NFCSTATUS status = NFCSTATUS_FAILED;
317
318    EXTNS_SetCallBackFlag(FALSE);
319    /* Set Completion Routine for CheckNdef */
320    NdefMap->CompletionRoutine[0].CompletionRoutine = Mfc_CheckNdef_Completion_Routine;
321
322    gphNxpExtns_Context.CallBackMifare = phFriNfc_MifareStdMap_Process;
323    gphNxpExtns_Context.CallBackCtxt   = NdefMap;
324    status = phFriNfc_MifareStdMap_H_Reset(NdefMap);
325    if ( NFCSTATUS_SUCCESS == status)
326    {
327        status = phFriNfc_MifareStdMap_ChkNdef(NdefMap);
328        if ( status == NFCSTATUS_PENDING )
329        {
330            status = NFCSTATUS_SUCCESS;
331        }
332    }
333    if( status != NFCSTATUS_SUCCESS )
334    {
335        status = NFCSTATUS_FAILED;
336    }
337
338    return status;
339}
340
341/*******************************************************************************
342**
343** Function         Mfc_CheckNdef_Completion_Routine
344**
345** Description      Notify NDEF detection for Mifare Classic Tag to JNI
346**
347**                  Upon completion of NDEF detection, a
348**                  NFA_NDEF_DETECT_EVT will be sent, to notify the application
349**                  of the NDEF attributes (NDEF total memory size, current
350**                  size, etc.).
351**
352** Returns:         void
353**
354*******************************************************************************/
355STATIC void Mfc_CheckNdef_Completion_Routine(void *NdefCtxt, NFCSTATUS status)
356{
357    (void)NdefCtxt;
358    tNFA_CONN_EVT_DATA conn_evt_data;
359
360    conn_evt_data.ndef_detect.status = status;
361    if(NFCSTATUS_SUCCESS == status)
362    {
363        /* NDef Tag Detected */
364        conn_evt_data.ndef_detect.protocol   = NFA_PROTOCOL_MIFARE;
365        phFrinfc_MifareClassic_GetContainerSize(NdefMap,
366                                                (uint32_t *)&(conn_evt_data.ndef_detect.max_size),
367                                                (uint32_t *)&(conn_evt_data.ndef_detect.cur_size));
368        NdefInfo.NdefLength  = conn_evt_data.ndef_detect.max_size;
369        /* update local flags */
370        NdefInfo.is_ndef = 1;
371        NdefInfo.NdefActualSize = conn_evt_data.ndef_detect.cur_size;
372        if ( PH_NDEFMAP_CARD_STATE_READ_ONLY == NdefMap->CardState )
373        {
374            NXPLOG_EXTNS_D("Mfc_CheckNdef_Completion_Routine : READ_ONLY_CARD");
375            conn_evt_data.ndef_detect.flags = RW_NDEF_FL_READ_ONLY;
376        }
377        else
378        {
379            conn_evt_data.ndef_detect.flags = RW_NDEF_FL_SUPPORTED | RW_NDEF_FL_FORMATED;
380        }
381    }
382    else
383    {
384        /* NDEF Detection failed for other reasons */
385        conn_evt_data.ndef_detect.cur_size = 0;
386        conn_evt_data.ndef_detect.max_size = 0;
387        conn_evt_data.ndef_detect.flags    = RW_NDEF_FL_UNKNOWN;
388
389        /* update local flags */
390        NdefInfo.is_ndef = 0;
391        NdefInfo.NdefActualSize = conn_evt_data.ndef_detect.cur_size;
392    }
393    (*gphNxpExtns_Context.p_conn_cback) (NFA_NDEF_DETECT_EVT, &conn_evt_data);
394
395    return;
396}
397/*******************************************************************************
398**
399** Function         Mfc_ReadNdef_Completion_Routine
400**
401** Description      Notify NDEF read completion for Mifare Classic Tag to JNI
402**
403**                  Upon completion of NDEF read, a
404**                  NFA_READ_CPLT_EVT will be sent, to notify the application
405**                  with the NDEF data and status
406**
407** Returns:         void
408**
409*******************************************************************************/
410STATIC void Mfc_ReadNdef_Completion_Routine(void *NdefCtxt, NFCSTATUS status)
411{
412    (void)NdefCtxt;
413    tNFA_CONN_EVT_DATA conn_evt_data;
414    tNFA_NDEF_EVT_DATA p_data;
415
416    conn_evt_data.status = status;
417#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
418    pthread_mutex_lock(&SharedDataMutex);
419#endif
420    if(NFCSTATUS_SUCCESS == status)
421    {
422        p_data.ndef_data.len    = NdefInfo.psUpperNdefMsg->length;
423        p_data.ndef_data.p_data = NdefInfo.psUpperNdefMsg->buffer;
424        (*gphNxpExtns_Context.p_ndef_cback) (NFA_NDEF_DATA_EVT, &p_data);
425    }
426    else
427    {
428    }
429
430    (*gphNxpExtns_Context.p_conn_cback) (NFA_READ_CPLT_EVT, &conn_evt_data);
431
432    if( NdefInfo.psUpperNdefMsg->buffer != NULL)
433    {
434        free (NdefInfo.psUpperNdefMsg->buffer);
435        NdefInfo.psUpperNdefMsg->buffer = NULL;
436    }
437#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
438    pthread_mutex_unlock(&SharedDataMutex);
439#endif
440    return;
441}
442
443/*******************************************************************************
444**
445** Function         Mfc_WriteNdef_Completion_Routine
446**
447** Description      Notify NDEF write completion for Mifare Classic Tag to JNI
448**
449**                  Upon completion of NDEF write, a
450**                  NFA_WRITE_CPLT_EVT will be sent along with status
451**
452** Returns:         void
453**
454*******************************************************************************/
455STATIC void Mfc_WriteNdef_Completion_Routine(void *NdefCtxt, NFCSTATUS status)
456{
457    (void)NdefCtxt;
458    tNFA_CONN_EVT_DATA conn_evt_data;
459
460    conn_evt_data.status = status;
461    (*gphNxpExtns_Context.p_conn_cback) (NFA_WRITE_CPLT_EVT, &conn_evt_data);
462
463    return;
464}
465
466/*******************************************************************************
467**
468** Function         Mfc_FormatNdef_Completion_Routine
469**
470** Description      Notify NDEF format completion for Mifare Classic Tag to JNI
471**
472**                  Upon completion of NDEF format, a
473**                  NFA_FORMAT_CPLT_EVT will be sent along with status
474**
475** Returns:         void
476**
477*******************************************************************************/
478STATIC void Mfc_FormatNdef_Completion_Routine(void *NdefCtxt, NFCSTATUS status)
479{
480    (void)NdefCtxt;
481    tNFA_CONN_EVT_DATA conn_evt_data;
482
483    conn_evt_data.status = status;
484    (*gphNxpExtns_Context.p_conn_cback) (NFA_FORMAT_CPLT_EVT, &conn_evt_data);
485
486    return;
487}
488
489/*******************************************************************************
490**
491** Function          phFriNfc_ValidateParams
492**
493** Description      This function is a common function which validates NdefRd
494**                  and NdefWr parameters.
495**
496** Returns          NFCSTATUS_SUCCESS  - All the params are valid
497**                  NFCSTATUS_FAILED   - otherwise
498**
499*******************************************************************************/
500STATIC NFCSTATUS phFriNfc_ValidateParams(uint8_t             *PacketData,
501                                    uint32_t            *PacketDataLength,
502                                    uint8_t             Offset,
503                                    phFriNfc_NdefMap_t  *pNdefMap,
504                                    uint8_t             bNdefReq)
505{
506
507    if( (pNdefMap == NULL) || (PacketData == NULL)
508        || (PacketDataLength == NULL) )
509    {
510        return NFCSTATUS_FAILED;
511    }
512
513    if( pNdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID )
514    {
515        return NFCSTATUS_FAILED;
516    }
517
518    if( bNdefReq == PH_FRINFC_NDEF_READ_REQ )
519    {
520        if( (Offset != PH_FRINFC_NDEFMAP_SEEK_CUR) && (Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN) )
521        {
522            return NFCSTATUS_FAILED;
523        }
524        if( pNdefMap->CardState == PH_NDEFMAP_CARD_STATE_INITIALIZED )
525        {
526            pNdefMap->NumOfBytesRead  = PacketDataLength;
527            *pNdefMap->NumOfBytesRead = 0;
528            return NFCSTATUS_EOF_NDEF_CONTAINER_REACHED;
529        }
530        if( (pNdefMap->PrevOperation == PH_FRINFC_NDEFMAP_WRITE_OPE) &&
531            (Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN) )
532        {
533            return NFCSTATUS_FAILED; /* return INVALID_DEVICE_REQUEST */
534        }
535        if( Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN )
536        {
537            pNdefMap->ApduBuffIndex = 0;
538            *pNdefMap->DataCount    = 0;
539        }
540        else if ( (pNdefMap->bPrevReadMode == PH_FRINFC_NDEFMAP_SEEK_BEGIN) ||
541                  (pNdefMap->bPrevReadMode == PH_FRINFC_NDEFMAP_SEEK_CUR) )
542        {
543
544        }
545        else
546        {
547            return NFCSTATUS_FAILED;
548        }
549    }
550    else if( bNdefReq == PH_FRINFC_NDEF_WRITE_REQ )
551    {
552        if( pNdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY )
553        {
554            pNdefMap->WrNdefPacketLength  = PacketDataLength;
555            *pNdefMap->WrNdefPacketLength = 0x00;
556            return NFCSTATUS_NOT_ALLOWED;
557        }
558    }
559
560    return NFCSTATUS_SUCCESS;
561}
562
563/*******************************************************************************
564**
565** Function         Mfc_SetRdOnly_Completion_Routine
566**
567** Description      Notify NDEF read only completion for Mifare Classic Tag to JNI
568**
569**                  Upon completion of NDEF format, a
570**                  NFA_SET_TAG_RO_EVT will be sent along with status
571**
572** Returns:         void
573**
574*******************************************************************************/
575STATIC void Mfc_SetRdOnly_Completion_Routine(void *NdefCtxt, NFCSTATUS status)
576{
577    (void)NdefCtxt;
578    tNFA_CONN_EVT_DATA conn_evt_data;
579    ALOGE("Mfc_SetRdOnly_Completion_Routine status = 0x%x", status);
580    conn_evt_data.status = status;
581    (*gphNxpExtns_Context.p_conn_cback) (NFA_SET_TAG_RO_EVT, &conn_evt_data);
582
583    return;
584}
585
586/*******************************************************************************
587**
588** Function        Mfc_SetReadOnly
589**
590**
591** Description:    It triggers ConvertToReadOnly  for Mifare Classic Tag.
592**
593** Returns:
594**                  NFCSTATUS_SUCCESS if successfully initiated
595**                  NFCSTATUS_FAILED otherwise
596**
597*******************************************************************************/
598NFCSTATUS Mfc_SetReadOnly(uint8_t *secrtkey, uint8_t len)
599{
600    NXPLOG_EXTNS_D("%s Entering ", __FUNCTION__);
601    NFCSTATUS status = NFCSTATUS_FAILED;
602    uint8_t mif_secrete_key[6] = {0};
603    uint8_t id = 0;
604    EXTNS_SetCallBackFlag(FALSE);
605    memcpy(mif_secrete_key,secrtkey,len);
606    gphNxpExtns_Context.CallBackMifare = phFriNfc_MifareStdMap_Process;
607    gphNxpExtns_Context.CallBackCtxt   = NdefMap;
608    for (id = 0; id < len; id++)
609    {
610        ALOGD("secrtkey[%d] = 0x%x", id, secrtkey[id]);
611        ALOGD("mif_secrete_key[%d] = 0x%x", id, mif_secrete_key[id]);
612    }
613    /* Set Completion Routine for ReadNdef */
614    NdefMap->CompletionRoutine[0].CompletionRoutine = Mfc_SetRdOnly_Completion_Routine;
615    if(NdefInfo.is_ndef == 0)
616    {
617        status = NFCSTATUS_NON_NDEF_COMPLIANT;
618        goto Mfc_SetRdOnly;
619    }
620    else if( (NdefInfo.is_ndef == 1) && (NdefInfo.NdefActualSize == 0) )
621    {
622#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
623        pthread_mutex_lock(&SharedDataMutex);
624#endif
625        NdefInfo.psUpperNdefMsg->length = NdefInfo.NdefActualSize;
626#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
627        pthread_mutex_unlock(&SharedDataMutex);
628#endif
629        status = NFCSTATUS_SUCCESS;
630        goto Mfc_SetRdOnly;
631    }
632    else
633    {
634        status = phFriNfc_MifareStdMap_ConvertToReadOnly(NdefMap, mif_secrete_key);
635    }
636    if ( NFCSTATUS_PENDING == status )
637    {
638        status = NFCSTATUS_SUCCESS;
639    }
640
641Mfc_SetRdOnly:
642    return status;
643}
644
645/*******************************************************************************
646**
647** Function         Mfc_ReadNdef
648**
649** Description      It triggers receiving of the NDEF message from Mifare Classic Tag.
650**
651**
652** Returns:
653**                  NFCSTATUS_SUCCESS - if successfully initiated
654**                  NFCSTATUS_FAILED  - otherwise
655**
656*******************************************************************************/
657NFCSTATUS Mfc_ReadNdef(void)
658{
659    NFCSTATUS status = NFCSTATUS_FAILED;
660    uint8_t            *PacketData = NULL;
661    uint32_t           *PacketDataLength = NULL;
662    phLibNfc_Ndef_EOffset_t Offset;
663
664    EXTNS_SetCallBackFlag(FALSE);
665
666    Offset = phLibNfc_Ndef_EBegin;
667
668    gphNxpExtns_Context.CallBackMifare = phFriNfc_MifareStdMap_Process;
669    gphNxpExtns_Context.CallBackCtxt   = NdefMap;
670#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
671    pthread_mutex_lock(&SharedDataMutex);
672#endif
673    if(NdefInfo.is_ndef == 0)
674    {
675        status = NFCSTATUS_NON_NDEF_COMPLIANT;
676        goto Mfc_RdNdefEnd;
677    }
678    else if( (NdefInfo.is_ndef == 1) && (NdefInfo.NdefActualSize == 0) )
679    {
680        NdefInfo.psUpperNdefMsg->length = NdefInfo.NdefActualSize;
681        status = NFCSTATUS_SUCCESS;
682        goto Mfc_RdNdefEnd;
683    }
684    else
685    {
686        NdefInfo.psUpperNdefMsg->buffer = malloc(NdefInfo.NdefActualSize);
687        if ( NULL == NdefInfo.psUpperNdefMsg->buffer)
688        {
689           goto Mfc_RdNdefEnd;
690        }
691        NdefInfo.psUpperNdefMsg->length = NdefInfo.NdefActualSize;
692
693        /* Set Completion Routine for ReadNdef */
694        NdefMap->CompletionRoutine[1].CompletionRoutine = Mfc_ReadNdef_Completion_Routine;
695        NdefInfo.NdefContinueRead = (uint8_t) ((phLibNfc_Ndef_EBegin==Offset) ?
696                                                        PH_FRINFC_NDEFMAP_SEEK_BEGIN :
697                                                        PH_FRINFC_NDEFMAP_SEEK_CUR);
698    }
699
700    PacketData             = NdefInfo.psUpperNdefMsg->buffer;
701    PacketDataLength       = (uint32_t*)&(NdefInfo.psUpperNdefMsg->length);
702    NdefMap->bCurrReadMode = Offset;
703    status = phFriNfc_ValidateParams (PacketData, PacketDataLength, Offset, NdefMap, PH_FRINFC_NDEF_READ_REQ);
704    if( status != NFCSTATUS_SUCCESS )
705    {
706        goto Mfc_RdNdefEnd;
707    }
708
709    status = phFriNfc_MifareStdMap_RdNdef(NdefMap, PacketData, PacketDataLength, Offset);
710
711    if(NFCSTATUS_INSUFFICIENT_STORAGE == status)
712    {
713        NdefInfo.psUpperNdefMsg->length = 0x00;
714        status = NFCSTATUS_SUCCESS;
715    }
716
717    if ( NFCSTATUS_PENDING == status )
718    {
719        status = NFCSTATUS_SUCCESS;
720    }
721
722Mfc_RdNdefEnd:
723    if( status != NFCSTATUS_SUCCESS )
724    {
725        if ( NULL != NdefInfo.psUpperNdefMsg->buffer )
726        {
727            free(NdefInfo.psUpperNdefMsg->buffer);
728            NdefInfo.psUpperNdefMsg->buffer = NULL;
729        }
730        status = NFCSTATUS_FAILED;
731    }
732#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
733    pthread_mutex_unlock(&SharedDataMutex);
734#endif
735    return status;
736
737}
738/*******************************************************************************
739**
740** Function         Mfc_PresenceCheck
741**
742** Description      It triggers receiving of the NDEF message from Mifare Classic Tag.
743**
744**
745** Returns:
746**                  NFCSTATUS_SUCCESS - if successfully initiated
747**                  NFCSTATUS_FAILED  - otherwise
748**
749*******************************************************************************/
750NFCSTATUS Mfc_PresenceCheck(void)
751{
752    NFCSTATUS status = NFCSTATUS_SUCCESS;
753
754    if (gAuthCmdBuf.auth_status == TRUE)
755    {
756        EXTNS_SetCallBackFlag(FALSE);
757        status = nativeNfcExtns_doTransceive(gAuthCmdBuf.pauth_cmd->buffer,
758             gAuthCmdBuf.pauth_cmd->length);
759        if (status != NFCSTATUS_PENDING)
760        {
761            gAuthCmdBuf.auth_sent = FALSE;
762            status = NFCSTATUS_FAILED;
763        }
764        else
765        {
766            gAuthCmdBuf.auth_sent = TRUE;
767            status = NFCSTATUS_SUCCESS;
768        }
769    }
770    else
771    {
772        status = NFCSTATUS_NOT_ALLOWED;
773    }
774    NXPLOG_EXTNS_D("%s status = 0x%x", __FUNCTION__, status);
775    return status;
776}
777/*******************************************************************************
778**
779** Function         Mfc_WriteNdef
780**
781** Description      It triggers the NDEF data write to Mifare Classic Tag.
782**
783**
784** Returns:
785**                  NFCSTATUS_SUCCESS - if successfully initiated
786**                  NFCSTATUS_FAILED  - otherwise
787**
788*******************************************************************************/
789NFCSTATUS Mfc_WriteNdef(uint8_t *p_data, uint32_t len)
790{
791    NFCSTATUS status = NFCSTATUS_SUCCESS;
792    uint8_t            *PacketData = NULL;
793    uint32_t           *PacketDataLength = NULL;
794
795    if( p_data == NULL || len == 0 )
796    {
797        NXPLOG_EXTNS_E("MFC Error: Invalid Parameters to Ndef Write");
798        status = NFCSTATUS_FAILED;
799        goto Mfc_WrNdefEnd;
800    }
801
802    EXTNS_SetCallBackFlag(FALSE);
803    gphNxpExtns_Context.CallBackMifare = phFriNfc_MifareStdMap_Process;
804    gphNxpExtns_Context.CallBackCtxt   = NdefMap;
805#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
806    pthread_mutex_lock(&SharedDataMutex);
807#endif
808    if( NdefInfo.is_ndef == PH_LIBNFC_INTERNAL_CHK_NDEF_NOT_DONE )
809    {
810        status = NFCSTATUS_REJECTED;
811        goto Mfc_WrNdefEnd;
812    }
813    else if( NdefInfo.is_ndef == 0 )
814    {
815        status = NFCSTATUS_NON_NDEF_COMPLIANT;
816        goto Mfc_WrNdefEnd;
817    }
818    else if( len > NdefInfo.NdefLength )
819    {
820        status = NFCSTATUS_NOT_ENOUGH_MEMORY;
821        goto Mfc_WrNdefEnd;
822    }
823    else
824    {
825        NdefInfo.psUpperNdefMsg->buffer = p_data;
826        NdefInfo.psUpperNdefMsg->length = len;
827
828        NdefInfo.AppWrLength    = len;
829        NdefMap->CompletionRoutine[2].CompletionRoutine = Mfc_WriteNdef_Completion_Routine;
830        if( 0 == len )
831        {
832            /* TODO: Erase the Tag */
833        }
834        else
835        {
836            NdefMap->ApduBuffIndex = 0x00;
837            *NdefMap->DataCount    = 0x00;
838            PacketData             = NdefInfo.psUpperNdefMsg->buffer;
839            PacketDataLength       = &(NdefInfo.dwWrLength);
840            NdefMap->WrNdefPacketLength = PacketDataLength;
841            NdefInfo.dwWrLength = len;
842
843            status = phFriNfc_ValidateParams (PacketData, PacketDataLength, 0, NdefMap, PH_FRINFC_NDEF_WRITE_REQ);
844            if( status != NFCSTATUS_SUCCESS )
845            {
846                goto Mfc_WrNdefEnd;
847            }
848
849            status = phFriNfc_MifareStdMap_WrNdef(NdefMap, PacketData, PacketDataLength, PH_FRINFC_NDEFMAP_SEEK_BEGIN);
850
851            if ( status == NFCSTATUS_PENDING )
852            {
853                status = NFCSTATUS_SUCCESS;
854            }
855        }
856    }
857
858Mfc_WrNdefEnd:
859#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
860    pthread_mutex_unlock(&SharedDataMutex);
861#endif
862    if( status != NFCSTATUS_SUCCESS )
863    {
864        status = NFCSTATUS_FAILED;
865    }
866    return status;
867}
868/*******************************************************************************
869**
870** Function          phFriNfc_NdefSmtCrd_Reset__
871**
872** Description      This function Resets the component instance to the initial
873**                  state and initializes the internal variables.
874**
875** Returns          NFCSTATUS_SUCCESS
876**
877*******************************************************************************/
878STATIC NFCSTATUS phFriNfc_NdefSmtCrd_Reset__(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt,
879                                      uint8_t *SendRecvBuffer,
880                                      uint16_t *SendRecvBuffLen)
881{
882//    NFCSTATUS status = NFCSTATUS_FAILED;                      /*commented to eliminate unused variable warning*/
883    uint8_t     index;
884
885    /* Initialize the state to Init */
886    NdefSmtCrdFmt->State = PH_FRINFC_SMTCRDFMT_STATE_RESET_INIT;
887
888    for(index = 0;index<PH_FRINFC_SMTCRDFMT_CR;index++)
889    {
890        /* Initialize the NdefMap Completion Routine to Null */
891        NdefSmtCrdFmt->CompletionRoutine[index].CompletionRoutine = NULL;
892        /* Initialize the NdefMap Completion Routine context to Null  */
893        NdefSmtCrdFmt->CompletionRoutine[index].Context = NULL;
894    }
895
896    /* Trx Buffer registered */
897    NdefSmtCrdFmt->SendRecvBuf = SendRecvBuffer;
898
899    /* Trx Buffer Size */
900    NdefSmtCrdFmt->SendRecvLength = SendRecvBuffLen;
901
902    /* Register Transfer Buffer Length */
903    NdefSmtCrdFmt->SendLength = 0;
904
905    /* Initialize the Format status flag*/
906    NdefSmtCrdFmt->FmtProcStatus = 0;
907
908    /* Reset the Card Type */
909    NdefSmtCrdFmt->CardType = 0;
910
911    /* Reset MapCompletion Info*/
912    NdefSmtCrdFmt->SmtCrdFmtCompletionInfo.CompletionRoutine = NULL;
913    NdefSmtCrdFmt->SmtCrdFmtCompletionInfo.Context = NULL;
914
915    phFriNfc_MfStd_Reset(NdefSmtCrdFmt);
916
917    return NFCSTATUS_SUCCESS;
918}
919
920/*******************************************************************************
921**
922** Function         Mfc_FormatNdef
923**
924** Description      It triggers the NDEF format of Mifare Classic Tag.
925**
926**
927** Returns:
928**                  NFCSTATUS_SUCCESS - if successfully initiated
929**                  NFCSTATUS_FAILED  - otherwise
930**
931*******************************************************************************/
932NFCSTATUS Mfc_FormatNdef(uint8_t *secretkey, uint8_t len)
933{
934    NFCSTATUS status = NFCSTATUS_FAILED;
935    uint8_t   mif_std_key[6] = {0};
936//    static uint8_t   Index;                                               /*commented to eliminate unused variable warning*/
937    uint8_t     sak = 0;
938
939    EXTNS_SetCallBackFlag(FALSE);
940
941    memcpy(mif_std_key,secretkey,len);
942    memcpy(current_key,secretkey,len);
943
944    if( NULL == NdefSmtCrdFmt ||
945        NULL == NdefMap || NULL == NdefMap->SendRecvBuf )
946    {
947        goto Mfc_FormatEnd;
948    }
949    NdefSmtCrdFmt->pTransceiveInfo = NdefMap->pTransceiveInfo;
950
951    gphNxpExtns_Context.CallBackMifare = phFriNfc_MfStd_Process;
952    gphNxpExtns_Context.CallBackCtxt   = NdefSmtCrdFmt;
953
954    NdefInfo.NdefSendRecvLen = NDEF_SENDRCV_BUF_LEN;
955    phFriNfc_NdefSmtCrd_Reset__(NdefSmtCrdFmt, NdefMap->SendRecvBuf, &(NdefInfo.NdefSendRecvLen));
956
957    /* Register Callbacks */
958    NdefSmtCrdFmt->CompletionRoutine[0].CompletionRoutine = Mfc_FormatNdef_Completion_Routine;
959    NdefSmtCrdFmt->CompletionRoutine[1].CompletionRoutine = Mfc_FormatNdef_Completion_Routine;
960    NdefSmtCrdFmt->psRemoteDevInfo = NdefMap->psRemoteDevInfo;
961    sak = NdefSmtCrdFmt->psRemoteDevInfo->RemoteDevInfo.Iso14443A_Info.Sak;
962
963    if((0x08 == (sak & 0x18)) || (0x18 == (sak & 0x18)) ||
964       (0x01 == sak))
965    {
966        NdefSmtCrdFmt->CardType = (uint8_t) (((sak & 0x18) == 0x08)?
967                        PH_FRINFC_SMTCRDFMT_MFSTD_1K_CRD:(((sak & 0x19) == 0x19)?
968                        PH_FRINFC_SMTCRDFMT_MFSTD_2K_CRD:
969                        PH_FRINFC_SMTCRDFMT_MFSTD_4K_CRD));
970        status = phFriNfc_MfStd_Format( NdefSmtCrdFmt, mif_std_key);
971    }
972
973    if( NFCSTATUS_PENDING == status )
974    {
975        status = NFCSTATUS_SUCCESS;
976    }
977
978Mfc_FormatEnd:
979    if( status != NFCSTATUS_SUCCESS )
980    {
981        status = NFCSTATUS_FAILED;
982    }
983
984    return status;
985}
986
987/*******************************************************************************
988**
989** Function         phNxNciExtns_MifareStd_Reconnect
990**
991** Description      This function sends the deactivate command to NFCC for Mifare
992**
993**
994** Returns:
995**                  NFCSTATUS_PENDING - if successfully initiated
996**                  NFCSTATUS_FAILED  - otherwise
997**
998*******************************************************************************/
999NFCSTATUS phNxNciExtns_MifareStd_Reconnect(void)
1000{
1001    tNFA_STATUS status;
1002
1003    EXTNS_SetDeactivateFlag(TRUE);
1004    if (NFA_STATUS_OK != (status = NFA_Deactivate (TRUE))) /* deactivate to sleep state */
1005    {
1006        NXPLOG_EXTNS_E ("%s: deactivate failed, status = %d", __FUNCTION__, status);
1007        return NFCSTATUS_FAILED;
1008    }
1009
1010    return NFCSTATUS_PENDING;
1011
1012}
1013
1014/*******************************************************************************
1015**
1016** Function         Mfc_DeactivateCbackSelect
1017**
1018** Description      This function select the Mifare tag
1019**
1020**
1021** Returns:         void
1022**
1023*******************************************************************************/
1024void Mfc_DeactivateCbackSelect(void)
1025{
1026    tNFA_STATUS status;
1027
1028    EXTNS_SetConnectFlag(TRUE);
1029    if (NFA_STATUS_OK != (status = NFA_Select (0x01, phNciNfc_e_RfProtocolsMifCProtocol,
1030                                                     phNciNfc_e_RfInterfacesTagCmd_RF)))
1031    {
1032        NXPLOG_EXTNS_E ("%s: NFA_Select failed, status = %d", __FUNCTION__, status);
1033    }
1034
1035    return;
1036}
1037
1038/*******************************************************************************
1039**
1040** Function         Mfc_ActivateCback
1041**
1042** Description      This function invoke the callback when receive the response
1043**
1044**
1045** Returns:         void
1046**
1047**
1048*******************************************************************************/
1049void Mfc_ActivateCback(void)
1050{
1051    gphNxpExtns_Context.CallBackMifare(gphNxpExtns_Context.CallBackCtxt, NFCSTATUS_SUCCESS);
1052    return;
1053}
1054
1055/*******************************************************************************
1056**
1057** Function         Mfc_Transceive
1058**
1059** Description      Sends raw frame to Mifare Classic Tag.
1060**
1061** Returns          NFCSTATUS_SUCCESS - if successfully initiated
1062**                  NFCSTATUS_FAILED  - otherwise
1063**
1064*******************************************************************************/
1065NFCSTATUS Mfc_Transceive(uint8_t *p_data, uint32_t len)
1066{
1067    NFCSTATUS status = NFCSTATUS_FAILED;
1068    uint8_t i = 0x00;
1069
1070    gphNxpExtns_Context.RawWriteCallBack = FALSE;
1071    gphNxpExtns_Context.CallBackMifare = NULL;
1072    gphNxpExtns_Context.CallBackCtxt   = NdefMap;
1073
1074    EXTNS_SetCallBackFlag(TRUE);
1075    if( p_data[0] == 0x60 || p_data[0] == 0x61 )
1076    {
1077
1078        NdefMap->Cmd.MfCmd = p_data[0];
1079
1080        NdefMap->SendRecvBuf[i++] = p_data[1];
1081
1082        NdefMap->SendRecvBuf[i++] = p_data[6]; /* TODO, handle 7 byte UID */
1083        NdefMap->SendRecvBuf[i++] = p_data[7];
1084        NdefMap->SendRecvBuf[i++] = p_data[8];
1085        NdefMap->SendRecvBuf[i++] = p_data[9];
1086        NdefMap->SendRecvBuf[i++] = p_data[10];
1087        NdefMap->SendRecvBuf[i++] = p_data[11];
1088
1089        status = phFriNfc_ExtnsTransceive(NdefMap->pTransceiveInfo,
1090                              NdefMap->Cmd,
1091                              NdefMap->SendRecvBuf,
1092                              NdefMap->SendLength,
1093                              NdefMap->SendRecvLength);
1094    }
1095    else if( p_data[0] == 0xA0 )
1096    {
1097        EXTNS_SetCallBackFlag(FALSE);
1098        NdefMap->Cmd.MfCmd = phNfc_eMifareWrite16;
1099        gphNxpExtns_Context.RawWriteCallBack = TRUE;
1100
1101        memcpy(NdefMap->SendRecvBuf, &p_data[1], len-1);
1102        NdefMap->SendLength = len-1;
1103        status = phFriNfc_ExtnsTransceive(NdefMap->pTransceiveInfo,
1104                              NdefMap->Cmd,
1105                              NdefMap->SendRecvBuf,
1106                              NdefMap->SendLength,
1107                              NdefMap->SendRecvLength);
1108    }
1109    else if( (p_data[0] == phNfc_eMifareInc) || (p_data[0] == phNfc_eMifareDec) )
1110    {
1111
1112        EXTNS_SetCallBackFlag(FALSE);
1113        NdefMap->Cmd.MfCmd = p_data[0];
1114        gphNxpExtns_Context.RawWriteCallBack = TRUE;
1115
1116        memcpy(NdefMap->SendRecvBuf, &p_data[1], len-1);
1117        NdefMap->SendLength = len - 1;
1118        status = phFriNfc_ExtnsTransceive(NdefMap->pTransceiveInfo,
1119                              NdefMap->Cmd,
1120                              NdefMap->SendRecvBuf,
1121                              NdefMap->SendLength,
1122                              NdefMap->SendRecvLength);
1123    }
1124    else if( ((p_data[0] == phNfc_eMifareTransfer) || (p_data[0] == phNfc_eMifareRestore)) && (len == 2) )
1125    {
1126        NdefMap->Cmd.MfCmd = p_data[0];
1127        if ((p_data[0] == phNfc_eMifareRestore))
1128        {
1129            EXTNS_SetCallBackFlag(FALSE);
1130            gphNxpExtns_Context.RawWriteCallBack = TRUE;
1131            memcpy(NdefMap->SendRecvBuf, &p_data[1], len -1);
1132            NdefMap->SendLength = len - 1;
1133        }
1134        else
1135        {
1136            memcpy(NdefMap->SendRecvBuf, p_data, len);
1137            NdefMap->SendLength = len;
1138        }
1139        status = phFriNfc_ExtnsTransceive(NdefMap->pTransceiveInfo,
1140                              NdefMap->Cmd,
1141                              NdefMap->SendRecvBuf,
1142                              NdefMap->SendLength,
1143                              NdefMap->SendRecvLength);
1144
1145    }
1146    else
1147    {
1148        NdefMap->Cmd.MfCmd = phNfc_eMifareRaw;
1149
1150        memcpy(NdefMap->SendRecvBuf, p_data, len);
1151        NdefMap->SendLength = len;
1152        status = phFriNfc_ExtnsTransceive(NdefMap->pTransceiveInfo,
1153                              NdefMap->Cmd,
1154                              NdefMap->SendRecvBuf,
1155                              NdefMap->SendLength,
1156                              NdefMap->SendRecvLength);
1157    }
1158    if (NFCSTATUS_PENDING == status)
1159    {
1160        status = NFCSTATUS_SUCCESS;
1161    }
1162    else
1163    {
1164        NXPLOG_EXTNS_E("ERROR: Mfc_Transceive = 0x%x", status);
1165    }
1166
1167    return status;
1168}
1169
1170/*******************************************************************************
1171**
1172** Function         nativeNfcExtns_doTransceive
1173**
1174** Description      Sends raw frame to BCM stack.
1175**
1176** Returns          NFCSTATUS_PENDING - if successfully initiated
1177**                  NFCSTATUS_FAILED  - otherwise
1178**
1179*******************************************************************************/
1180STATIC NFCSTATUS nativeNfcExtns_doTransceive(uint8_t *buff, uint16_t buffSz)
1181{
1182    NFCSTATUS wStatus = NFCSTATUS_PENDING;
1183    tNFA_STATUS status = NFA_SendRawFrame (buff, buffSz, NFA_DM_DEFAULT_PRESENCE_CHECK_START_DELAY);
1184
1185    if (status != NFA_STATUS_OK)
1186    {
1187        NXPLOG_EXTNS_E ("%s: fail send; error=%d", __FUNCTION__, status);
1188        wStatus = NFCSTATUS_FAILED;
1189    }
1190
1191    return wStatus;
1192}
1193
1194/*******************************************************************************
1195**
1196** Function          phNciNfc_RecvMfResp
1197**
1198** Description      This function shall be invoked as part of ReaderMgmt data
1199**                  exchange sequence handler on receiving response/data from NFCC
1200**
1201** Returns          NFCSTATUS_SUCCESS - Data Reception is successful
1202**                  NFCSTATUS_FAILED  - Data Reception failed
1203**
1204*******************************************************************************/
1205STATIC NFCSTATUS
1206phNciNfc_RecvMfResp(phNciNfc_Buff_t* RspBuffInfo,
1207                        NFCSTATUS          wStatus
1208                       )
1209{
1210    NFCSTATUS               status = NFCSTATUS_SUCCESS;
1211    uint16_t                wPldDataSize = 0;
1212    phNciNfc_ExtnRespId_t   RecvdExtnRspId = phNciNfc_e_InvalidRsp;
1213    uint16_t                wRecvDataSz = 0;
1214
1215    if(NULL == RspBuffInfo)
1216    {
1217      status = NFCSTATUS_FAILED;
1218    }
1219    else
1220    {
1221        if((0 == (RspBuffInfo->wLen))
1222                || (PH_NCINFC_STATUS_OK != wStatus)
1223                || (NULL == (RspBuffInfo->pBuff))
1224                )
1225        {
1226            status = NFCSTATUS_FAILED;
1227        }
1228        else
1229        {
1230            RecvdExtnRspId = (phNciNfc_ExtnRespId_t)RspBuffInfo->pBuff[0];
1231
1232            switch(RecvdExtnRspId)
1233            {
1234                case phNciNfc_e_MfXchgDataRsp:
1235                {
1236                        /* check the status byte */
1237                    if( PH_NCINFC_STATUS_OK == RspBuffInfo->pBuff[RspBuffInfo->wLen-1] )
1238                    {
1239                        status = NFCSTATUS_SUCCESS;
1240
1241                        /* DataLen = TotalRecvdLen - (sizeof(RspId) + sizeof(Status)) */
1242                        wPldDataSize = ((RspBuffInfo->wLen) -
1243                            (PHNCINFC_EXTNID_SIZE + PHNCINFC_EXTNSTATUS_SIZE));
1244                        wRecvDataSz = NCI_MAX_DATA_LEN;
1245
1246                        /* wPldDataSize = wPldDataSize-1; ==> ignoring the last status byte appended with data */
1247                        if((wPldDataSize) <= wRecvDataSz)
1248                        {
1249                            /* Extract the data part from pBuff[2] & fill it to be sent to upper layer */
1250                            memcpy(NdefMap->SendRecvBuf, &(RspBuffInfo->pBuff[1]),(wPldDataSize));
1251                            /* update the number of bytes received from lower layer,excluding the status byte */
1252                            *(NdefMap->SendRecvLength) = wPldDataSize;
1253                        }
1254                        else
1255                        {
1256                            //TODO:- Map some status for remaining extra data received to be sent back to caller??
1257                            status = NFCSTATUS_FAILED;
1258                        }
1259                    }
1260                    else
1261                    {
1262                        status = NFCSTATUS_FAILED;
1263                    }
1264                }
1265                break;
1266
1267                case phNciNfc_e_MfcAuthRsp:
1268                {
1269                    /* check the status byte */
1270                    if(PH_NCINFC_STATUS_OK == RspBuffInfo->pBuff[1])
1271                    {
1272                        if (gAuthCmdBuf.auth_sent ==  TRUE)
1273                        {
1274                            MfcPresenceCheckResult(NFCSTATUS_SUCCESS);
1275                            return NFCSTATUS_SUCCESS;
1276                        }
1277                        gAuthCmdBuf.auth_status = TRUE;
1278                        status = NFCSTATUS_SUCCESS;
1279
1280                        /* DataLen = TotalRecvdLen - (sizeof(RspId) + sizeof(Status)) */
1281                        wPldDataSize = ((RspBuffInfo->wLen) -
1282                            (PHNCINFC_EXTNID_SIZE + PHNCINFC_EXTNSTATUS_SIZE));
1283
1284                        /* Extract the data part from pBuff[2] & fill it to be sent to upper layer */
1285                        memcpy(NdefMap->SendRecvBuf, &(RspBuffInfo->pBuff[2]),wPldDataSize);
1286                        /* update the number of bytes received from lower layer,excluding the status byte */
1287                        *(NdefMap->SendRecvLength) = wPldDataSize;
1288                    }
1289                    else
1290                    {
1291                        if (gAuthCmdBuf.auth_sent ==  TRUE)
1292                        {
1293                            gAuthCmdBuf.auth_status = FALSE;
1294                            MfcPresenceCheckResult(NFCSTATUS_FAILED);
1295                            return NFCSTATUS_SUCCESS;
1296                        }
1297                        else
1298                        {
1299                            /* Reset the stored auth command buffer */
1300                            memset(gAuthCmdBuf.pauth_cmd->buffer, 0 , NCI_MAX_DATA_LEN);
1301                            gAuthCmdBuf.pauth_cmd->length = 0;
1302                            gAuthCmdBuf.auth_status = FALSE;
1303                        }
1304                        status = NFCSTATUS_FAILED;
1305                    }
1306                }
1307                break;
1308
1309                default:
1310                {
1311                    status = NFCSTATUS_FAILED;
1312                }
1313                break;
1314            }
1315        }
1316    }
1317
1318    return status;
1319}
1320
1321/*******************************************************************************
1322**
1323** Function         phLibNfc_SendWrt16CmdPayload
1324**
1325** Description      This function map the raw write cmd
1326**
1327** Returns          NFCSTATUS_SUCCESS            - Command framing done
1328**                  NFCSTATUS_INVALID_PARAMETER  - Otherwise
1329**
1330*******************************************************************************/
1331STATIC NFCSTATUS phLibNfc_SendWrt16CmdPayload(phNfc_sTransceiveInfo_t*    pTransceiveInfo,
1332                                    pphNciNfc_TransceiveInfo_t   pMappedTranscvIf)
1333{
1334    NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
1335
1336    if( (NULL != pTransceiveInfo->sSendData.buffer) &&
1337        (0 != (pTransceiveInfo->sSendData.length)))
1338    {
1339        memcpy(pMappedTranscvIf->tSendData.pBuff, pTransceiveInfo->sSendData.buffer,
1340                              (pTransceiveInfo->sSendData.length));
1341        pMappedTranscvIf->tSendData.wLen              = pTransceiveInfo->sSendData.length;
1342        pMappedTranscvIf->uCmd.T2TCmd                 = phNciNfc_eT2TRaw;
1343    }
1344    else
1345    {
1346        wStatus = NFCSTATUS_INVALID_PARAMETER;
1347    }
1348
1349    if ( gphNxpExtns_Context.RawWriteCallBack == TRUE )
1350    {
1351        EXTNS_SetCallBackFlag(TRUE);
1352        gphNxpExtns_Context.RawWriteCallBack = FALSE;
1353    }
1354
1355    return wStatus;
1356}
1357
1358/*******************************************************************************
1359**
1360** Function         phLibNfc_SendIncDecCmdPayload
1361**
1362** Description      This function prepares the Increment/Decrement Value to be
1363**                  sent. This is called after sending the Increment/Decrement
1364**                  command is already sent and successfull
1365**
1366** Returns          NFCSTATUS_SUCCESS            - Payload framing done
1367**                  NFCSTATUS_INVALID_PARAMETER  - Otherwise
1368**
1369*******************************************************************************/
1370STATIC NFCSTATUS phLibNfc_SendIncDecCmdPayload(phNfc_sTransceiveInfo_t*    pTransceiveInfo,
1371                                    pphNciNfc_TransceiveInfo_t   pMappedTranscvIf)
1372{
1373    NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
1374
1375    if( (NULL != pTransceiveInfo->sSendData.buffer) &&
1376        (0 != (pTransceiveInfo->sSendData.length)))
1377    {
1378        memcpy(pMappedTranscvIf->tSendData.pBuff, pTransceiveInfo->sSendData.buffer,
1379                              (pTransceiveInfo->sSendData.length));
1380        pMappedTranscvIf->tSendData.wLen              = pTransceiveInfo->sSendData.length;
1381        pMappedTranscvIf->uCmd.T2TCmd                 = phNciNfc_eT2TRaw;
1382    }
1383    else
1384    {
1385        wStatus = NFCSTATUS_INVALID_PARAMETER;
1386    }
1387
1388    if ( gphNxpExtns_Context.RawWriteCallBack == TRUE )
1389    {
1390        EXTNS_SetCallBackFlag(TRUE);
1391        gphNxpExtns_Context.RawWriteCallBack = FALSE;
1392    }
1393
1394    return wStatus;
1395}
1396
1397/*******************************************************************************
1398**
1399** Function         Mfc_RecvPacket
1400**
1401** Description      Decodes Mifare Classic Tag Response
1402**                  This is called from NFA_SendRaw Callback
1403**
1404** Returns:
1405**                  NFCSTATUS_SUCCESS - if successfully initiated
1406**                  NFCSTATUS_FAILED  - otherwise
1407**
1408*******************************************************************************/
1409NFCSTATUS Mfc_RecvPacket(uint8_t *buff, uint8_t buffSz)
1410{
1411    NFCSTATUS    status = NFCSTATUS_SUCCESS;
1412    phNciNfc_Buff_t         RspBuff;
1413    uint8_t *pcmd_buff;
1414    uint16_t buffSize;
1415
1416    RspBuff.pBuff = buff;
1417    RspBuff.wLen  = buffSz;
1418    status = phNciNfc_RecvMfResp(&RspBuff, status);
1419    if (TRUE == gAuthCmdBuf.auth_sent)
1420    {
1421        ALOGD("%s Mfc Check Presnece in progress", __FUNCTION__);
1422        gAuthCmdBuf.auth_sent = FALSE;
1423        return status;
1424    }
1425    if( TRUE == gphNxpExtns_Context.writecmdFlag && (NFCSTATUS_SUCCESS == status ))
1426    {
1427        pcmd_buff = (uint8_t *)malloc((uint32_t)MAX_BUFF_SIZE);
1428        if( NULL == pcmd_buff )
1429        {
1430            return NFCSTATUS_FAILED;
1431        }
1432        buffSize = MAX_BUFF_SIZE;
1433        gphNxpExtns_Context.writecmdFlag = FALSE;
1434        phLibNfc_SendWrt16CmdPayload(NdefMap->pTransceiveInfo, &tNciTranscvInfo);
1435        status = phNciNfc_SendMfReq(tNciTranscvInfo, pcmd_buff, &buffSize);
1436        if ( NFCSTATUS_PENDING != status )
1437        {
1438            NXPLOG_EXTNS_E("ERROR : Mfc_RecvPacket: 0x%x", status);
1439        }
1440        else
1441        {
1442            status = NFCSTATUS_SUCCESS;
1443        }
1444        if( pcmd_buff != NULL )
1445        {
1446            free(pcmd_buff);
1447            pcmd_buff = NULL;
1448        }
1449    }
1450    else if( TRUE == gphNxpExtns_Context.incrdecflag && (NFCSTATUS_SUCCESS == status ))
1451    {
1452        pcmd_buff = (uint8_t *)malloc((uint32_t)MAX_BUFF_SIZE);
1453        if( NULL == pcmd_buff )
1454        {
1455            return NFCSTATUS_FAILED;
1456        }
1457        buffSize = MAX_BUFF_SIZE;
1458        gphNxpExtns_Context.incrdecflag = FALSE;
1459        phLibNfc_SendIncDecCmdPayload(NdefMap->pTransceiveInfo, &tNciTranscvInfo);
1460        status = phNciNfc_SendMfReq(tNciTranscvInfo, pcmd_buff, &buffSize);
1461        if ( NFCSTATUS_PENDING != status )
1462        {
1463            NXPLOG_EXTNS_E("ERROR : Mfc_RecvPacket: 0x%x", status);
1464        }
1465        else
1466        {
1467            status = NFCSTATUS_SUCCESS;
1468        }
1469        gphNxpExtns_Context.incrdecstatusflag = TRUE;
1470        if( pcmd_buff != NULL )
1471        {
1472            free(pcmd_buff);
1473            pcmd_buff = NULL;
1474        }
1475
1476    }
1477    else
1478    {
1479        if( gphNxpExtns_Context.CallBackMifare != NULL )
1480        {
1481            if( (gphNxpExtns_Context.incrdecstatusflag == TRUE) && status == 0xB2 )
1482            {
1483                gphNxpExtns_Context.incrdecstatusflag = FALSE;
1484                status = NFCSTATUS_SUCCESS;
1485            }
1486            gphNxpExtns_Context.CallBackMifare(gphNxpExtns_Context.CallBackCtxt, status);
1487        }
1488    }
1489
1490    return status;
1491}
1492
1493/*******************************************************************************
1494**
1495** Function         phNciNfc_MfCreateXchgDataHdr
1496**
1497** Description      This function builds the payload header for mifare XchgData
1498**                  request to be sent to NFCC.
1499**
1500** Returns          NFCSTATUS_PENDING            - Command framing done
1501**                  NFCSTATUS_FAILED             - Otherwise
1502**
1503*******************************************************************************/
1504STATIC
1505NFCSTATUS
1506phNciNfc_MfCreateXchgDataHdr(phNciNfc_TransceiveInfo_t tTranscvInfo,
1507                             uint8_t *buff, uint16_t *buffSz)
1508
1509{
1510    NFCSTATUS   status = NFCSTATUS_SUCCESS;
1511    uint8_t     i = 0;
1512
1513    buff[i++] = phNciNfc_e_MfRawDataXchgHdr;
1514    memcpy(&buff[i],tTranscvInfo.tSendData.pBuff,tTranscvInfo.tSendData.wLen);
1515    *buffSz = i + tTranscvInfo.tSendData.wLen;
1516
1517    status = nativeNfcExtns_doTransceive(buff, (uint16_t) *buffSz);
1518
1519    return status;
1520}
1521
1522/*******************************************************************************
1523**
1524** Function         phNciNfc_MfCreateAuthCmdHdr
1525**
1526** Description      This function builds the payload header for mifare
1527**                  classic Authenticate command to be sent to NFCC.
1528**
1529** Returns          NFCSTATUS_PENDING            - Command framing done
1530**                  NFCSTATUS_FAILED             - Otherwise
1531**
1532*******************************************************************************/
1533STATIC
1534NFCSTATUS
1535phNciNfc_MfCreateAuthCmdHdr(phNciNfc_TransceiveInfo_t tTranscvInfo,
1536                            uint8_t    bBlockAddr,
1537                            uint8_t    *buff,
1538                            uint16_t    *buffSz)
1539{
1540    NFCSTATUS               status = NFCSTATUS_SUCCESS;
1541//    pphNciNfc_RemoteDevInformation_t  pActivDev = NULL;           /*commented to eliminate unused variable warning*/
1542    uint8_t bKey = 0x00;
1543
1544    /*No need to check range of block address*/
1545    /*To check for Authenticate A or Authenticate B type command*/
1546    if(PHNCINFC_AUTHENTICATION_KEYB ==
1547       tTranscvInfo.tSendData.pBuff[0] )
1548    {
1549        bKey = bKey | PHNCINFC_ENABLE_KEY_B;
1550    }
1551
1552    /*TO Do last 4 bits of Key to be set based of firmware implementation*/
1553    /*this value is hardcoded but based on firmware implementation change this value*/
1554    bKey = (bKey | PHNCINFC_AUTHENTICATION_KEY);
1555
1556    bKey |= tTranscvInfo.tSendData.pBuff[2];
1557
1558    /*For authentication extension no need to copy tSendData buffer of tTranscvInfo */
1559    tTranscvInfo.tSendData.wLen = 0x00;
1560
1561    buff[0] = phNciNfc_e_MfcAuthReq;
1562    buff[1] = bBlockAddr;
1563    buff[2] = bKey;
1564
1565    *buffSz = 0x03;
1566    if (bKey & PH_NCINFC_MIFARECLASSIC_EMBEDDED_KEY)
1567    {
1568        memcpy(&buff[3],&tTranscvInfo.tSendData.pBuff[3], PHLIBNFC_MFC_AUTHKEYLEN);
1569        *buffSz += PHLIBNFC_MFC_AUTHKEYLEN;
1570    }
1571    /* Store the auth command buffer to use further for presence check */
1572    if (gAuthCmdBuf.pauth_cmd != NULL)
1573    {
1574        memset(gAuthCmdBuf.pauth_cmd->buffer, 0, NCI_MAX_DATA_LEN);
1575        gAuthCmdBuf.pauth_cmd->length = *buffSz;
1576        memcpy(gAuthCmdBuf.pauth_cmd->buffer, buff, *buffSz);
1577    }
1578    status = nativeNfcExtns_doTransceive(buff,(uint16_t) *buffSz);
1579
1580    return status;
1581}
1582
1583/*******************************************************************************
1584**
1585** Function         phNciNfc_SendMfReq
1586**
1587** Description      This function shall be invoked as part of ReaderMgmt data
1588**                  exchange sequence handler.
1589**                  It shall send the request packet to NFCC.
1590**
1591** Returns          NFCSTATUS_PENDING  - Send request is Pending
1592**                  NFCSTATUS_FAILED   - otherwise
1593**
1594*******************************************************************************/
1595STATIC NFCSTATUS
1596phNciNfc_SendMfReq(phNciNfc_TransceiveInfo_t tTranscvInfo, uint8_t *buff, uint16_t *buffSz)
1597{
1598    NFCSTATUS status = NFCSTATUS_SUCCESS;
1599
1600    switch(tTranscvInfo.uCmd.T2TCmd)
1601    {
1602        case phNciNfc_eT2TRaw:
1603        {
1604            status = phNciNfc_MfCreateXchgDataHdr(tTranscvInfo, buff, buffSz);
1605        }
1606        break;
1607        case phNciNfc_eT2TAuth:
1608        {
1609            status = phNciNfc_MfCreateAuthCmdHdr(tTranscvInfo,
1610                (tTranscvInfo.bAddr), buff, buffSz);
1611        }
1612        break;
1613        default:
1614        {
1615            status = NFCSTATUS_FAILED;
1616            break;
1617        }
1618    }
1619
1620    return status;
1621}
1622
1623/*******************************************************************************
1624**
1625** Function         phLibNfc_CalSectorAddress
1626**
1627** Description      This function update the sector address for Mifare classic
1628**
1629** Returns          none
1630**
1631*******************************************************************************/
1632STATIC void phLibNfc_CalSectorAddress(uint8_t *Sector_Address)
1633{
1634    uint8_t BlockNumber = 0x00;
1635
1636    if(NULL != Sector_Address)
1637    {
1638        BlockNumber = *Sector_Address;
1639        if(BlockNumber >= PHLIBNFC_MIFARESTD4K_BLK128)
1640        {
1641            *Sector_Address = (uint8_t)(PHLIBNFC_MIFARESTD_SECTOR_NO32 +
1642                              ((BlockNumber - PHLIBNFC_MIFARESTD4K_BLK128)/
1643                               PHLIBNFC_MIFARESTD_BLOCK_BYTES));
1644        }
1645        else
1646        {
1647            *Sector_Address = BlockNumber/PHLIBNFC_NO_OF_BLKPERSECTOR;
1648        }
1649     }
1650    else
1651    {
1652    }
1653
1654    return;
1655}
1656
1657/*******************************************************************************
1658**
1659** Function         phLibNfc_GetKeyNumberMFC
1660**
1661** Description      This function find key number based on authentication command
1662**
1663** Returns          NFCSTATUS_SUCCESS  - If found the key number
1664**                  NFCSTATUS_FAILED   - otherwise
1665**
1666*******************************************************************************/
1667STATIC NFCSTATUS phLibNfc_GetKeyNumberMFC(uint8_t *buffer,uint8_t *bKey)
1668{
1669    int32_t sdwStat   = 0X00;
1670    NFCSTATUS wStatus = NFCSTATUS_INVALID_PARAMETER;
1671
1672    /*Key Configuration
1673    uint8_t NdefKey[PHLIBNFC_MFC_AUTHKEYLEN] = {0xD3,0XF7,0xD3,0XF7,0xD3,0XF7};
1674    uint8_t RawKey[PHLIBNFC_MFC_AUTHKEYLEN] = {0xFF,0XFF,0xFF,0XFF,0xFF,0XFF};
1675    uint8_t MadKey[PHLIBNFC_MFC_AUTHKEYLEN] = {0xA0,0XA1,0xA2,0XA3,0xA4,0XA5};
1676    uint8_t Key[PHLIBNFC_MFC_AUTHKEYLEN] = {0x00,0x00,0x00,0x00,0x00,0x00}; */ /*Key used during ndef format*/
1677
1678    uint8_t bIndex = 0x00;
1679    uint8_t bNoOfKeys = 0x00;
1680
1681#if PHLIBNFC_NXPETENSION_CONFIGURE_MFKEYS
1682    uint8_t aMfc_keys[NXP_NUMBER_OF_MFC_KEYS][NXP_MFC_KEY_SIZE] = NXP_MFC_KEYS;
1683#else
1684    uint8_t aMfc_keys[1][1] = {{0x00}};
1685#endif
1686
1687    if(NULL != bKey &&
1688       NULL != buffer )
1689    {
1690       bNoOfKeys = sizeof(aMfc_keys)/NXP_MFC_KEY_SIZE;
1691        /* Traverse through the keys stored to determine whether keys is preloaded key */
1692       for(bIndex = 0; bIndex < bNoOfKeys; bIndex++)
1693       {
1694           /* Check passed key is NDEF key */
1695           sdwStat = memcmp(&buffer[PHLIBNFC_MFCUIDLEN_INAUTHCMD],
1696                                  aMfc_keys[bIndex], PHLIBNFC_MFC_AUTHKEYLEN);
1697           if(!sdwStat)
1698           {
1699               NXPLOG_EXTNS_E("Mifare : phLibNfc_GetKeyNumberMFC Key found");
1700               *bKey = bIndex;
1701               wStatus = NFCSTATUS_SUCCESS;
1702               break;
1703           }
1704        }
1705       NXPLOG_EXTNS_E("Mifare : phLibNfc_GetKeyNumberMFC returning = 0x%x Key = 0x%x", wStatus, *bKey);
1706    }
1707    else
1708    {
1709        wStatus = NFCSTATUS_FAILED;
1710        NXPLOG_EXTNS_E("Mifare : phLibNfc_GetKeyNumberMFC returning = 0x%x", wStatus);
1711    }
1712
1713    return wStatus;
1714}
1715
1716/*******************************************************************************
1717**
1718** Function         phLibNfc_ChkAuthCmdMFC
1719**
1720** Description      This function Check Authentication command send is proper or not
1721**
1722** Returns          NFCSTATUS_SUCCESS  - Authenticate command is proper
1723**                  NFCSTATUS_FAILED   - otherwise
1724**
1725*******************************************************************************/
1726STATIC NFCSTATUS phLibNfc_ChkAuthCmdMFC(phNfc_sTransceiveInfo_t* pTransceiveInfo,
1727                                 uint8_t *bKey)
1728{
1729    NFCSTATUS wStatus  = NFCSTATUS_SUCCESS;
1730
1731    if(NULL != pTransceiveInfo &&
1732       NULL != pTransceiveInfo->sSendData.buffer &&
1733       0 != pTransceiveInfo->sSendData.length &&
1734       NULL != bKey)
1735    {
1736        if((pTransceiveInfo->cmd.MfCmd == phNfc_eMifareAuthentA ||
1737           pTransceiveInfo->cmd.MfCmd == phNfc_eMifareAuthentB ))
1738        {
1739            wStatus = phLibNfc_GetKeyNumberMFC(pTransceiveInfo->sSendData.buffer,bKey);
1740        }
1741        else
1742        {
1743            wStatus = NFCSTATUS_FAILED;
1744        }
1745    }else
1746    {
1747        wStatus = NFCSTATUS_FAILED;
1748    }
1749    return wStatus;
1750}
1751
1752/*******************************************************************************
1753**
1754** Function         phLibNfc_MifareMap
1755**
1756** Description      Mifare Mapping Utility function
1757**
1758** Returns          NFCSTATUS_SUCCESS             - Mapping is proper
1759**                  NFCSTATUS_INVALID_PARAMETER   - otherwise
1760**
1761*******************************************************************************/
1762STATIC NFCSTATUS phLibNfc_MifareMap(phNfc_sTransceiveInfo_t*    pTransceiveInfo,
1763                                    pphNciNfc_TransceiveInfo_t   pMappedTranscvIf)
1764{
1765    NFCSTATUS status = NFCSTATUS_SUCCESS;
1766    uint8_t bBuffIdx = 0;
1767    uint8_t bSectorNumber;
1768    uint8_t bKey = 0;
1769
1770    switch(pTransceiveInfo->cmd.MfCmd)
1771    {
1772        case phNfc_eMifareRead16:
1773        {
1774            if( (NULL != pTransceiveInfo->sRecvData.buffer) &&
1775                (0 != (pTransceiveInfo->sRecvData.length)))
1776            {
1777                pMappedTranscvIf->tSendData.pBuff[bBuffIdx++] = phNfc_eMifareRead16;
1778                pMappedTranscvIf->tSendData.pBuff[bBuffIdx++] = pTransceiveInfo->addr;
1779                pMappedTranscvIf->tSendData.wLen              = bBuffIdx;
1780                pMappedTranscvIf->uCmd.T2TCmd                 = phNciNfc_eT2TRaw;
1781            }
1782            else
1783            {
1784                status = NFCSTATUS_INVALID_PARAMETER;
1785            }
1786        }
1787        break;
1788
1789        case phNfc_eMifareWrite16:
1790        {
1791            if( (NULL != pTransceiveInfo->sSendData.buffer) &&
1792                (0 != (pTransceiveInfo->sSendData.length)))
1793            {
1794                pMappedTranscvIf->tSendData.pBuff[bBuffIdx++] = phNfc_eMifareWrite16;
1795                pMappedTranscvIf->tSendData.pBuff[bBuffIdx++] = pTransceiveInfo->addr;
1796                memcpy(&(pMappedTranscvIf->tSendData.pBuff[bBuffIdx]),pTransceiveInfo->sSendData.buffer,
1797                                      (pTransceiveInfo->sSendData.length));
1798                pMappedTranscvIf->tSendData.wLen              = bBuffIdx + pTransceiveInfo->sSendData.length;
1799                pMappedTranscvIf->uCmd.T2TCmd                 = phNciNfc_eT2TRaw;
1800            }
1801            else
1802            {
1803                status = NFCSTATUS_INVALID_PARAMETER;
1804            }
1805        }
1806        break;
1807
1808        case phNfc_eMifareAuthentA:
1809        case phNfc_eMifareAuthentB:
1810        {
1811            if( (NULL != pTransceiveInfo->sSendData.buffer) &&
1812                (0 != (pTransceiveInfo->sSendData.length)) &&
1813                (NULL != pTransceiveInfo->sRecvData.buffer) &&
1814                (0 != (pTransceiveInfo->sRecvData.length))
1815                )
1816            {
1817                status = phLibNfc_ChkAuthCmdMFC(pTransceiveInfo, &bKey);
1818                if(NFCSTATUS_FAILED != status )
1819                {
1820                    bSectorNumber = pTransceiveInfo->addr;
1821                    phLibNfc_CalSectorAddress(&bSectorNumber);
1822                    /*For creating extension command header pTransceiveInfo's MfCmd get used*/
1823                    pMappedTranscvIf->tSendData.pBuff[bBuffIdx++] = pTransceiveInfo->cmd.MfCmd;
1824                    pMappedTranscvIf->tSendData.pBuff[bBuffIdx++] = bSectorNumber;
1825                    pMappedTranscvIf->uCmd.T2TCmd = phNciNfc_eT2TAuth;
1826                    pMappedTranscvIf->bAddr = bSectorNumber;
1827                    pMappedTranscvIf->bNumBlock = pTransceiveInfo->NumBlock;
1828                    if(NFCSTATUS_SUCCESS == status)
1829                    {
1830                        pMappedTranscvIf->tSendData.pBuff[bBuffIdx++] = bKey;
1831                        (pMappedTranscvIf->tSendData.wLen) = (uint16_t)(bBuffIdx);
1832
1833                    }
1834                    else if(NFCSTATUS_INVALID_PARAMETER == status)
1835                    {
1836                        bKey = bKey | PH_NCINFC_MIFARECLASSIC_EMBEDDED_KEY;
1837                        pMappedTranscvIf->tSendData.pBuff[bBuffIdx++] = bKey;
1838                        memcpy(&pMappedTranscvIf->tSendData.pBuff[bBuffIdx],
1839                                &pTransceiveInfo->sSendData.buffer[PHLIBNFC_MFCUIDLEN_INAUTHCMD], PHLIBNFC_MFC_AUTHKEYLEN);
1840
1841                        (pMappedTranscvIf->tSendData.wLen) = (uint16_t)(bBuffIdx + PHLIBNFC_MFC_AUTHKEYLEN);
1842                        status = NFCSTATUS_SUCCESS;
1843                    }
1844                    else
1845                    {
1846                        /* do nothing */
1847                    }
1848                }
1849            }
1850            else
1851            {
1852                status = NFCSTATUS_INVALID_PARAMETER;
1853            }
1854        }
1855        break;
1856
1857        case phNfc_eMifareRaw:
1858        {
1859
1860        }
1861        break;
1862
1863        default:
1864        {
1865            status = NFCSTATUS_INVALID_PARAMETER;
1866            break;
1867        }
1868    }
1869
1870    return status;
1871}
1872
1873/*******************************************************************************
1874**
1875** Function         phLibNfc_MapCmds
1876**
1877** Description      This function maps the command request from libnfc level to nci level
1878**
1879** Returns          NFCSTATUS_SUCCESS           - Mapping of command is successful
1880**                  NFCSTATUS_INVALID_PARAMETER - One or more of the supplied
1881**                  parameters could not be interpreted properly
1882**
1883*******************************************************************************/
1884STATIC NFCSTATUS phLibNfc_MapCmds(phNciNfc_RFDevType_t         RemDevType,
1885                           phNfc_sTransceiveInfo_t*  pTransceiveInfo,
1886                           pphNciNfc_TransceiveInfo_t   pMappedTranscvIf)
1887{
1888
1889    NFCSTATUS status = NFCSTATUS_SUCCESS;
1890
1891    if((NULL == pTransceiveInfo) || (NULL == pMappedTranscvIf))
1892    {
1893        return NFCSTATUS_FAILED;
1894    }
1895    switch(RemDevType)
1896    {
1897        case phNciNfc_eMifare1k_PICC:
1898        case phNciNfc_eMifare4k_PICC:
1899        {
1900            status = phLibNfc_MifareMap(pTransceiveInfo,pMappedTranscvIf);
1901            break;
1902        }
1903        default:
1904        {
1905            break;
1906        }
1907    }
1908
1909    return status;
1910}
1911
1912/*******************************************************************************
1913**
1914** Function         phLibNfc_SendAuthCmd
1915**
1916** Description      This function Send authentication command to NFCC
1917**
1918** Returns          NFCSTATUS_SUCCESS           - Parameters are proper
1919**                  NFCSTATUS_INVALID_PARAMETER - Otherwise
1920**
1921*******************************************************************************/
1922STATIC NFCSTATUS phLibNfc_SendAuthCmd(phNfc_sTransceiveInfo_t *pTransceiveInfo,
1923                                      phNciNfc_TransceiveInfo_t  *tNciTranscvInfo)
1924{
1925    NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
1926
1927    wStatus = phLibNfc_MapCmds(phNciNfc_eMifare1k_PICC, pTransceiveInfo, tNciTranscvInfo);
1928
1929    return wStatus;
1930}
1931
1932/*******************************************************************************
1933**
1934** Function         phLibNfc_SendWrt16Cmd
1935**
1936** Description      This function maps Mifarewirte16 commands
1937**
1938** Returns          NFCSTATUS_SUCCESS           - Parameters are mapped
1939**                  NFCSTATUS_INVALID_PARAMETER - Otherwise
1940**
1941*******************************************************************************/
1942STATIC NFCSTATUS phLibNfc_SendWrt16Cmd(phNfc_sTransceiveInfo_t*    pTransceiveInfo,
1943                                    pphNciNfc_TransceiveInfo_t   pMappedTranscvIf)
1944{
1945    NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
1946    uint8_t bBuffIdx = 0x00;
1947
1948    if( (NULL != pTransceiveInfo->sSendData.buffer) &&
1949        (0 != (pTransceiveInfo->sSendData.length)))
1950    {
1951        pMappedTranscvIf->tSendData.pBuff[bBuffIdx++] = phNfc_eMifareWrite16;
1952        pMappedTranscvIf->tSendData.pBuff[bBuffIdx++] = pTransceiveInfo->addr;
1953        pMappedTranscvIf->tSendData.wLen              = bBuffIdx;
1954        pMappedTranscvIf->uCmd.T2TCmd                 = phNciNfc_eT2TRaw;
1955    }
1956    else
1957    {
1958        wStatus = NFCSTATUS_INVALID_PARAMETER;
1959    }
1960
1961    return wStatus;
1962}
1963
1964/*******************************************************************************
1965**
1966** Function         phLibNfc_SendIncDecCmd
1967**
1968** Description      This function prepares the Increment/Decrement command
1969**                  to be sent, increment/decrement value is sent separately
1970**
1971** Returns          NFCSTATUS_SUCCESS           - Params are mapped
1972**                  NFCSTATUS_INVALID_PARAMETER - Otherwise
1973**
1974*******************************************************************************/
1975STATIC NFCSTATUS phLibNfc_SendIncDecCmd(phNfc_sTransceiveInfo_t*    pTransceiveInfo,
1976                                    pphNciNfc_TransceiveInfo_t   pMappedTranscvIf,
1977                                    uint8_t IncDecCmd)
1978{
1979    NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
1980    uint8_t bBuffIdx = 0x00;
1981
1982    if( (NULL != pTransceiveInfo->sSendData.buffer) &&
1983        (0 != (pTransceiveInfo->sSendData.length)))
1984    {
1985        pMappedTranscvIf->tSendData.pBuff[bBuffIdx++] = IncDecCmd;
1986        pMappedTranscvIf->tSendData.pBuff[bBuffIdx++] = pTransceiveInfo->addr;
1987        pMappedTranscvIf->tSendData.wLen              = bBuffIdx;
1988        pMappedTranscvIf->uCmd.T2TCmd                 = phNciNfc_eT2TRaw;
1989    }
1990    else
1991    {
1992        wStatus = NFCSTATUS_INVALID_PARAMETER;
1993    }
1994
1995    return wStatus;
1996}
1997
1998/*******************************************************************************
1999**
2000** Function         phLibNfc_SendRawCmd
2001**
2002** Description      This function maps Mifare raw command
2003**
2004** Returns          NFCSTATUS_SUCCESS           - Parameters are mapped
2005**                  NFCSTATUS_INVALID_PARAMETER - Otherwise
2006**
2007*******************************************************************************/
2008STATIC NFCSTATUS phLibNfc_SendRawCmd(phNfc_sTransceiveInfo_t*    pTransceiveInfo,
2009                                    pphNciNfc_TransceiveInfo_t   pMappedTranscvIf)
2010{
2011    NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
2012//    uint8_t bBuffIdx = 0x00;                                  /*commented to eliminate unused variable warning*/
2013
2014    if( (NULL != pTransceiveInfo->sSendData.buffer) &&
2015        (0 != (pTransceiveInfo->sSendData.length)))
2016    {
2017        memcpy(pMappedTranscvIf->tSendData.pBuff, pTransceiveInfo->sSendData.buffer,
2018                              (pTransceiveInfo->sSendData.length));
2019        pMappedTranscvIf->tSendData.wLen              = pTransceiveInfo->sSendData.length;
2020        pMappedTranscvIf->uCmd.T2TCmd                 = phNciNfc_eT2TRaw;
2021    }
2022    else
2023    {
2024        wStatus = NFCSTATUS_INVALID_PARAMETER;
2025    }
2026
2027    return wStatus;
2028}
2029
2030/*******************************************************************************
2031**
2032** Function         phFriNfc_ExtnsTransceive
2033**
2034** Description      This function maps Mifare raw command and send it to NFCC
2035**
2036** Returns          NFCSTATUS_PENDING           - Operation successful
2037**                  NFCSTATUS_INVALID_PARAMETER - Otherwise
2038**
2039*******************************************************************************/
2040NFCSTATUS phFriNfc_ExtnsTransceive(phNfc_sTransceiveInfo_t *pTransceiveInfo,
2041                                   phNfc_uCmdList_t Cmd,
2042                                   uint8_t *SendRecvBuf,
2043                                   uint16_t SendLength,
2044                                   uint16_t *SendRecvLength)
2045{
2046    (void)SendRecvLength;
2047    NFCSTATUS status = NFCSTATUS_FAILED;
2048    uint8_t *buff=NULL;
2049    uint16_t buffSz=0;
2050    uint8_t i = 0;
2051    uint32_t length = SendLength;
2052    uint8_t restore_payload[]={0x00, 0x00, 0x00, 0x00,};
2053
2054    buff = (uint8_t *)malloc((uint32_t)MAX_BUFF_SIZE);
2055    if( NULL == buff )
2056    {
2057        return status;
2058    }
2059
2060    pTransceiveInfo->cmd = Cmd;
2061
2062    if( (Cmd.MfCmd == phNfc_eMifareAuthentA) ||
2063        (Cmd.MfCmd == phNfc_eMifareAuthentB) )
2064    {
2065        pTransceiveInfo->addr = SendRecvBuf[i++];
2066        pTransceiveInfo->sSendData.buffer[4] = SendRecvBuf[i++];
2067        pTransceiveInfo->sSendData.buffer[5] = SendRecvBuf[i++];
2068        pTransceiveInfo->sSendData.buffer[6] = SendRecvBuf[i++];
2069        pTransceiveInfo->sSendData.buffer[7] = SendRecvBuf[i++];
2070        pTransceiveInfo->sSendData.buffer[8] = SendRecvBuf[i++];
2071        pTransceiveInfo->sSendData.buffer[9] = SendRecvBuf[i++];
2072
2073        pTransceiveInfo->cmd.MfCmd = Cmd.MfCmd;
2074
2075        pTransceiveInfo->sSendData.length = length;
2076        pTransceiveInfo->sRecvData.length = MAX_BUFF_SIZE;
2077        status = phLibNfc_MifareMap(pTransceiveInfo, &tNciTranscvInfo);
2078    }
2079    else if( Cmd.MfCmd == phNfc_eMifareWrite16 )
2080    {
2081        pTransceiveInfo->addr = SendRecvBuf[i++];
2082        length = SendLength - i;
2083        memcpy(pTransceiveInfo->sSendData.buffer, &SendRecvBuf[i], length);
2084        pTransceiveInfo->sSendData.length = length;
2085        pTransceiveInfo->sRecvData.length = MAX_BUFF_SIZE;
2086
2087        gphNxpExtns_Context.writecmdFlag = TRUE;
2088
2089        status = phLibNfc_SendWrt16Cmd(pTransceiveInfo, &tNciTranscvInfo);
2090    }
2091    else if( (Cmd.MfCmd == phNfc_eMifareInc) || (Cmd.MfCmd == phNfc_eMifareDec) )
2092    {
2093        pTransceiveInfo->addr = SendRecvBuf[i++];
2094        length = SendLength - i;
2095        memcpy(pTransceiveInfo->sSendData.buffer, &SendRecvBuf[i], length);
2096        pTransceiveInfo->sSendData.length = length;
2097        pTransceiveInfo->sRecvData.length = MAX_BUFF_SIZE;
2098
2099        gphNxpExtns_Context.incrdecflag = TRUE;
2100
2101        status = phLibNfc_SendIncDecCmd(pTransceiveInfo, &tNciTranscvInfo, Cmd.MfCmd);
2102
2103    }
2104    else if( (Cmd.MfCmd == phNfc_eMifareRestore ) )
2105    {
2106        pTransceiveInfo->addr = SendRecvBuf[i++];
2107        length = SendLength - i;
2108        memcpy(pTransceiveInfo->sSendData.buffer, &restore_payload[0], sizeof(restore_payload));
2109        pTransceiveInfo->sSendData.length = length + sizeof(restore_payload);
2110        pTransceiveInfo->sRecvData.length = MAX_BUFF_SIZE;
2111
2112        gphNxpExtns_Context.incrdecflag = TRUE;
2113
2114        status = phLibNfc_SendIncDecCmd(pTransceiveInfo, &tNciTranscvInfo, Cmd.MfCmd);
2115
2116    }
2117    else if ((Cmd.MfCmd == phNfc_eMifareRaw) || (Cmd.MfCmd == phNfc_eMifareTransfer ))
2118    {
2119        pTransceiveInfo->cmd.MfCmd = phNciNfc_eT2TRaw;
2120        memcpy(pTransceiveInfo->sSendData.buffer, SendRecvBuf, length);
2121        pTransceiveInfo->sSendData.length = length;
2122        pTransceiveInfo->sRecvData.length = MAX_BUFF_SIZE;
2123        status = phLibNfc_SendRawCmd(pTransceiveInfo, &tNciTranscvInfo);
2124    }
2125    else
2126    {
2127        pTransceiveInfo->addr = SendRecvBuf[i++];
2128        length = SendLength - i;
2129        memcpy(pTransceiveInfo->sSendData.buffer, &SendRecvBuf[i], length);
2130        pTransceiveInfo->sSendData.length = length;
2131        pTransceiveInfo->sRecvData.length = MAX_BUFF_SIZE;
2132        status = phLibNfc_MifareMap(pTransceiveInfo, &tNciTranscvInfo);
2133    }
2134
2135    if (NFCSTATUS_SUCCESS == status )
2136    {
2137        status = phNciNfc_SendMfReq(tNciTranscvInfo, buff, &buffSz);
2138        if (NFCSTATUS_PENDING != status)
2139        {
2140            NXPLOG_EXTNS_E("ERROR : phNciNfc_SendMfReq()");
2141        }
2142    }
2143    else
2144    {
2145        NXPLOG_EXTNS_E (" ERROR : Sending phNciNfc_SendMfReq");
2146    }
2147    if( buff != NULL )
2148    {
2149        free(buff);
2150        buff = NULL;
2151    }
2152
2153    return status;
2154}
2155