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 23 phNxpExtns_Context_t gphNxpExtns_Context; 24 phNciNfc_TransceiveInfo_t tNciTranscvInfo; 25 phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt = NULL; 26 phFriNfc_NdefMap_t *NdefMap = NULL; 27 phLibNfc_NdefInfo_t NdefInfo; 28 #if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE) 29 pthread_mutex_t SharedDataMutex = PTHREAD_MUTEX_INITIALIZER; 30 #endif 31 UINT8 current_key[6]={0}; 32 phNci_mfc_auth_cmd_t gAuthCmdBuf; 33 STATIC NFCSTATUS phNciNfc_SendMfReq(phNciNfc_TransceiveInfo_t tTranscvInfo, 34 uint8_t *buff, uint16_t *buffSz); 35 STATIC NFCSTATUS phLibNfc_SendRawCmd(phNfc_sTransceiveInfo_t* pTransceiveInfo, 36 pphNciNfc_TransceiveInfo_t pMappedTranscvIf); 37 STATIC NFCSTATUS phLibNfc_SendWrt16Cmd(phNfc_sTransceiveInfo_t* pTransceiveInfo, 38 pphNciNfc_TransceiveInfo_t pMappedTranscvIf); 39 STATIC NFCSTATUS phLibNfc_SendAuthCmd(phNfc_sTransceiveInfo_t *pTransceiveInfo, 40 phNciNfc_TransceiveInfo_t *tNciTranscvInfo) __attribute__((unused)); 41 STATIC NFCSTATUS phLibNfc_MapCmds(phNciNfc_RFDevType_t RemDevType, 42 phNfc_sTransceiveInfo_t* pTransceiveInfo, 43 pphNciNfc_TransceiveInfo_t pMappedTranscvIf); 44 STATIC NFCSTATUS phLibNfc_MifareMap(phNfc_sTransceiveInfo_t* pTransceiveInfo, 45 pphNciNfc_TransceiveInfo_t pMappedTranscvIf); 46 STATIC NFCSTATUS phLibNfc_ChkAuthCmdMFC(phNfc_sTransceiveInfo_t* pTransceiveInfo, 47 uint8_t *bKey); 48 STATIC NFCSTATUS phLibNfc_GetKeyNumberMFC(uint8_t *buffer,uint8_t *bKey); 49 STATIC void phLibNfc_CalSectorAddress(uint8_t *Sector_Address); 50 STATIC NFCSTATUS phNciNfc_MfCreateAuthCmdHdr(phNciNfc_TransceiveInfo_t tTranscvInfo, 51 uint8_t bBlockAddr, 52 uint8_t *buff, 53 uint16_t *buffSz); 54 STATIC NFCSTATUS phNciNfc_MfCreateXchgDataHdr(phNciNfc_TransceiveInfo_t tTranscvInfo, 55 uint8_t *buff, uint16_t *buffSz); 56 STATIC NFCSTATUS phLibNfc_SendWrt16CmdPayload(phNfc_sTransceiveInfo_t* pTransceiveInfo, 57 pphNciNfc_TransceiveInfo_t pMappedTranscvIf); 58 STATIC NFCSTATUS phNciNfc_RecvMfResp(phNciNfc_Buff_t* RspBuffInfo, NFCSTATUS wStatus); 59 STATIC NFCSTATUS nativeNfcExtns_doTransceive(uint8_t *buff, uint16_t buffSz); 60 STATIC NFCSTATUS phFriNfc_NdefSmtCrd_Reset__(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt, 61 uint8_t *SendRecvBuffer, 62 uint16_t *SendRecvBuffLen); 63 STATIC NFCSTATUS phFriNfc_ValidateParams(uint8_t *PacketData, 64 uint32_t *PacketDataLength, 65 uint8_t Offset, 66 phFriNfc_NdefMap_t *pNdefMap, 67 uint8_t bNdefReq); 68 STATIC void Mfc_FormatNdef_Completion_Routine(void *NdefCtxt, NFCSTATUS status); 69 STATIC void Mfc_WriteNdef_Completion_Routine(void *NdefCtxt, NFCSTATUS status); 70 STATIC void Mfc_ReadNdef_Completion_Routine(void *NdefCtxt, NFCSTATUS status); 71 STATIC 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 *******************************************************************************/ 86 NFCSTATUS 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 *******************************************************************************/ 187 NFCSTATUS 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 291 clean_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 *******************************************************************************/ 314 NFCSTATUS 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 *******************************************************************************/ 355 STATIC 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 *******************************************************************************/ 410 STATIC 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 *******************************************************************************/ 455 STATIC 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 *******************************************************************************/ 478 STATIC 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 *******************************************************************************/ 500 STATIC 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 *******************************************************************************/ 575 STATIC 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 *******************************************************************************/ 598 NFCSTATUS 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 641 Mfc_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 *******************************************************************************/ 657 NFCSTATUS 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 722 Mfc_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 *******************************************************************************/ 750 NFCSTATUS 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 *******************************************************************************/ 789 NFCSTATUS 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 858 Mfc_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 *******************************************************************************/ 878 STATIC 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 *******************************************************************************/ 932 NFCSTATUS 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 978 Mfc_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 *******************************************************************************/ 999 NFCSTATUS 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 *******************************************************************************/ 1024 void 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 *******************************************************************************/ 1049 void 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 *******************************************************************************/ 1065 NFCSTATUS 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 *******************************************************************************/ 1180 STATIC 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 *******************************************************************************/ 1205 STATIC NFCSTATUS 1206 phNciNfc_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 *******************************************************************************/ 1331 STATIC 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 *******************************************************************************/ 1370 STATIC 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 *******************************************************************************/ 1409 NFCSTATUS 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 *******************************************************************************/ 1504 STATIC 1505 NFCSTATUS 1506 phNciNfc_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 *******************************************************************************/ 1533 STATIC 1534 NFCSTATUS 1535 phNciNfc_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 *******************************************************************************/ 1595 STATIC NFCSTATUS 1596 phNciNfc_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 *******************************************************************************/ 1632 STATIC 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 *******************************************************************************/ 1667 STATIC 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 *******************************************************************************/ 1726 STATIC 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 *******************************************************************************/ 1762 STATIC 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 *******************************************************************************/ 1884 STATIC 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 *******************************************************************************/ 1922 STATIC 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 *******************************************************************************/ 1942 STATIC 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 *******************************************************************************/ 1975 STATIC 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 *******************************************************************************/ 2008 STATIC 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 *******************************************************************************/ 2040 NFCSTATUS 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 = (phNfc_eMifareCmdList_t) 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
