1 /* 2 * Copyright (C) 2010 NXP Semiconductors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /*! 18 * =========================================================================== * 19 * * 20 * * 21 * \file phHciNfc_NfcIPMgmt.c * 22 * \brief HCI NFCIP-1 management routines. * 23 * * 24 * * 25 * Project: NFC-FRI-1.1 * 26 * * 27 * $Date: Tue Jun 8 09:32:31 2010 $ * 28 * $Author: ing04880 $ * 29 * $Revision: 1.33 $ * 30 * $Aliases: NFC_FRI1.1_WK1023_R35_1 $ 31 * * 32 * =========================================================================== * 33 */ 34 35 /* 36 ***************************** Header File Inclusion **************************** 37 */ 38 #include <phNfcCompId.h> 39 #include <phNfcHalTypes.h> 40 #include <phHciNfc_Pipe.h> 41 #include <phHciNfc_RFReader.h> 42 #include <phHciNfc_Emulation.h> 43 #include <phOsalNfc.h> 44 45 #if defined (ENABLE_P2P) 46 #include <phHciNfc_NfcIPMgmt.h> 47 /* 48 ****************************** Macro Definitions ******************************* 49 */ 50 /* RF Error */ 51 #define NFCIP_RF_NO_ERROR 0x00U 52 #define NFCIP_STATUS_MAX_VALUE 0x01U 53 54 /* Read and write to the below registry for initiator and target */ 55 #define NXP_NFCIP_MODE 0x01U 56 #define NXP_NFCIP_ATR_REQ 0x02U 57 #define NXP_NFCIP_ATR_RES 0x03U 58 #define NXP_NFCIP_PSL1 0x04U 59 #define NXP_NFCIP_PSL2 0x05U 60 #define NXP_NFCIP_DID 0x06U 61 #define NXP_NFCIP_NAD 0x07U 62 #define NXP_NFCIP_OPTIONS 0x08U 63 #define NXP_NFCIP_STATUS 0x09U 64 #define NXP_NFCIP_NFCID3I 0x0AU 65 #define NXP_NFCIP_NFCID3T 0x0BU 66 #define NXP_NFCIP_PARAM 0x0CU 67 #define NXP_NFCIP_MERGE 0x0DU 68 69 /* command */ 70 #define NXP_NFCIP_ATTREQUEST 0x12U 71 #define NXP_NFCI_CONTINUE_ACTIVATION 0x13U 72 73 /* Event */ 74 #define NXP_EVT_NFC_SND_DATA 0x01U 75 #define NXP_EVT_NFC_ACTIVATED 0x02U 76 #define NXP_EVT_NFC_DEACTIVATED 0x03U 77 #define NXP_EVT_NFC_RCV_DATA 0x04U 78 #define NXP_EVT_NFC_CONTINUE_MI 0x05U 79 80 #define NFCIP_DATE_RATE_FACTOR 0x40U 81 #define NFCIP_DATE_RATE_SHIFT 0x06U 82 #define NFCIP_DATA_RATE_CALC(val) \ 83 ((((uint8_t)(val) >> NFCIP_DATE_RATE_SHIFT) + \ 84 0x01U) * NFCIP_DATE_RATE_FACTOR) 85 #define NFCIP_COMM_INITIATOR_SHIFT 0x03 86 #define NFCIP_COMM_FACTOR 0x03 87 /* 88 *************************** Structure and Enumeration *************************** 89 */ 90 91 /* 92 *************************** Static Function Declaration ************************** 93 */ 94 static 95 NFCSTATUS 96 phHciNfc_NfcIP_InfoUpdate( 97 phHciNfc_sContext_t *psHciContext, 98 uint8_t index, 99 uint8_t *reg_value, 100 uint8_t reg_length 101 ); 102 103 static 104 NFCSTATUS 105 phHciNfc_NfcIP_RecvData( 106 phHciNfc_sContext_t *psHciContext, 107 void *pHwRef, 108 uint8_t *pResponse, 109 #ifdef ONE_BYTE_LEN 110 uint8_t length 111 #else 112 uint16_t length 113 #endif 114 ); 115 116 static 117 NFCSTATUS 118 phHciNfc_Recv_NfcIP_Response( 119 phHciNfc_sContext_t *psHciContext, 120 phHciNfc_Pipe_Info_t *ppipe_info, 121 uint8_t *pResponse, 122 #ifdef ONE_BYTE_LEN 123 uint8_t length 124 #else 125 uint16_t length 126 #endif 127 ); 128 129 static 130 NFCSTATUS 131 phHciNfc_Recv_NfcIP_Event( 132 phHciNfc_sContext_t *psHciContext, 133 void *pHwRef, 134 uint8_t *pEvent, 135 #ifdef ONE_BYTE_LEN 136 uint8_t length 137 #else 138 uint16_t length 139 #endif 140 ); 141 142 static 143 NFCSTATUS 144 phHciNfc_Recv_Initiator_Event( 145 void *psContext, 146 void *pHwRef, 147 uint8_t *pEvent, 148 #ifdef ONE_BYTE_LEN 149 uint8_t length 150 #else 151 uint16_t length 152 #endif 153 ); 154 155 static 156 NFCSTATUS 157 phHciNfc_Recv_Target_Event( 158 void *psContext, 159 void *pHwRef, 160 uint8_t *pEvent, 161 #ifdef ONE_BYTE_LEN 162 uint8_t length 163 #else 164 uint16_t length 165 #endif 166 ); 167 168 static 169 NFCSTATUS 170 phHciNfc_Recv_Initiator_Response( 171 void *psContext, 172 void *pHwRef, 173 uint8_t *pResponse, 174 #ifdef ONE_BYTE_LEN 175 uint8_t length 176 #else 177 uint16_t length 178 #endif 179 ); 180 181 static 182 NFCSTATUS 183 phHciNfc_Recv_Target_Response( 184 void *psContext, 185 void *pHwRef, 186 uint8_t *pResponse, 187 #ifdef ONE_BYTE_LEN 188 uint8_t length 189 #else 190 uint16_t length 191 #endif 192 ); 193 /* 194 *************************** Function Definitions *************************** 195 */ 196 197 NFCSTATUS 198 phHciNfc_Initiator_Init_Resources( 199 phHciNfc_sContext_t *psHciContext 200 ) 201 { 202 NFCSTATUS status = NFCSTATUS_SUCCESS; 203 phHciNfc_NfcIP_Info_t *p_init_info=NULL; 204 if( NULL == psHciContext ) 205 { 206 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 207 } 208 else 209 { 210 if (NULL != psHciContext->p_nfcip_info) 211 { 212 status = NFCSTATUS_SUCCESS; 213 } 214 else if(( NULL == psHciContext->p_nfcip_info ) && 215 (phHciNfc_Allocate_Resource((void **)(&p_init_info), 216 sizeof(phHciNfc_NfcIP_Info_t))== NFCSTATUS_SUCCESS) 217 ) 218 { 219 psHciContext->p_nfcip_info = p_init_info; 220 p_init_info->nfcip_type = NFCIP_INVALID; 221 p_init_info->current_seq = NFCIP_INVALID_SEQUENCE; 222 p_init_info->next_seq = NFCIP_INVALID_SEQUENCE; 223 p_init_info->p_init_pipe_info = NULL; 224 p_init_info->p_tgt_pipe_info = NULL; 225 } 226 else 227 { 228 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES); 229 } 230 231 } 232 return status; 233 } 234 235 NFCSTATUS 236 phHciNfc_Initiator_Get_PipeID( 237 phHciNfc_sContext_t *psHciContext, 238 uint8_t *ppipe_id 239 ) 240 { 241 NFCSTATUS status = NFCSTATUS_SUCCESS; 242 if( (NULL != psHciContext) 243 && ( NULL != ppipe_id ) 244 && ( NULL != psHciContext->p_nfcip_info ) 245 ) 246 { 247 phHciNfc_NfcIP_Info_t *p_init_info=NULL; 248 p_init_info = (phHciNfc_NfcIP_Info_t *) 249 psHciContext->p_nfcip_info ; 250 *ppipe_id = p_init_info->p_init_pipe_info->pipe.pipe_id ; 251 } 252 else 253 { 254 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 255 } 256 return status; 257 } 258 259 NFCSTATUS 260 phHciNfc_Initiator_Update_PipeInfo( 261 phHciNfc_sContext_t *psHciContext, 262 uint8_t pipeID, 263 phHciNfc_Pipe_Info_t *pPipeInfo 264 ) 265 { 266 NFCSTATUS status = NFCSTATUS_SUCCESS; 267 if( NULL == psHciContext ) 268 { 269 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 270 } 271 else if(NULL == psHciContext->p_nfcip_info) 272 { 273 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 274 } 275 else 276 { 277 phHciNfc_NfcIP_Info_t *p_init_info=NULL; 278 p_init_info = (phHciNfc_NfcIP_Info_t *) 279 psHciContext->p_nfcip_info ; 280 /* Update the pipe_id of the NFCIP-1 initiator Gate obtained from 281 the HCI Response */ 282 p_init_info->p_init_pipe_info = pPipeInfo; 283 p_init_info->p_init_pipe_info->pipe.pipe_id = pipeID; 284 /* Update the Response Receive routine of the NFCIP-1 initiator Gate */ 285 pPipeInfo->recv_resp = &phHciNfc_Recv_Initiator_Response; 286 /* Update the event Receive routine of the NFCIP-1 initiator Gate */ 287 pPipeInfo->recv_event = &phHciNfc_Recv_Initiator_Event; 288 } 289 return status; 290 } 291 292 NFCSTATUS 293 phHciNfc_NfcIP_Presence_Check( 294 phHciNfc_sContext_t *psHciContext, 295 void *pHwRef 296 ) 297 { 298 NFCSTATUS status = NFCSTATUS_SUCCESS; 299 300 if( (NULL == psHciContext) || (NULL == pHwRef) ) 301 { 302 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 303 } 304 else if((NULL == psHciContext->p_nfcip_info) || 305 (NFCIP_INVALID == 306 ((phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info))->nfcip_type)) 307 { 308 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 309 } 310 else 311 { 312 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 313 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 314 315 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 316 psHciContext->p_nfcip_info ; 317 p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)? 318 p_nfcipinfo->p_init_pipe_info : 319 p_nfcipinfo->p_tgt_pipe_info); 320 321 if(NULL == p_pipe_info ) 322 { 323 status = PHNFCSTVAL(CID_NFC_HCI, 324 NFCSTATUS_INVALID_HCI_INFORMATION); 325 } 326 else 327 { 328 phHciNfc_HCP_Packet_t *hcp_packet = NULL; 329 uint16_t length = HCP_HEADER_LEN; 330 uint8_t pipeid = 0; 331 332 pipeid = p_pipe_info->pipe.pipe_id; 333 psHciContext->tx_total = 0 ; 334 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer; 335 /* Construct the HCP Frame */ 336 phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT, 337 (uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_COMMAND, 338 (uint8_t)NXP_NFCIP_ATTREQUEST); 339 340 p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_COMMAND; 341 p_pipe_info->prev_msg = (uint8_t)NXP_NFCIP_ATTREQUEST; 342 psHciContext->tx_total = length; 343 psHciContext->response_pending = (uint8_t)TRUE; 344 345 /* Send the Constructed HCP packet to the lower layer */ 346 status = phHciNfc_Send_HCP( psHciContext, pHwRef); 347 p_pipe_info->prev_status = status; 348 } 349 } 350 return status; 351 } 352 353 static 354 NFCSTATUS 355 phHciNfc_Recv_Initiator_Response( 356 void *pContext, 357 void *pHwRef, 358 uint8_t *pResponse, 359 #ifdef ONE_BYTE_LEN 360 uint8_t length 361 #else 362 uint16_t length 363 #endif 364 ) 365 { 366 NFCSTATUS status = NFCSTATUS_SUCCESS; 367 phHciNfc_sContext_t *psHciContext = 368 (phHciNfc_sContext_t *)pContext ; 369 370 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse) 371 || (0 == length)) 372 { 373 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 374 } 375 else if(NULL == psHciContext->p_nfcip_info) 376 { 377 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 378 } 379 else 380 { 381 phHciNfc_NfcIP_Info_t *p_nfcip_info=NULL; 382 phHciNfc_Pipe_Info_t *p_pipe_info = NULL; 383 384 p_nfcip_info = (phHciNfc_NfcIP_Info_t *) 385 psHciContext->p_nfcip_info ; 386 p_pipe_info = p_nfcip_info->p_init_pipe_info; 387 if( NULL == p_pipe_info) 388 { 389 status = PHNFCSTVAL(CID_NFC_HCI, 390 NFCSTATUS_INVALID_HCI_INFORMATION); 391 } 392 else 393 { 394 status = phHciNfc_Recv_NfcIP_Response(psHciContext, 395 p_pipe_info, pResponse, 396 length); 397 if (NFCSTATUS_SUCCESS == status) 398 { 399 status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext, 400 UPDATE_SEQ); 401 } 402 } 403 } 404 return status; 405 } 406 407 static 408 NFCSTATUS 409 phHciNfc_Recv_Initiator_Event( 410 void *psContext, 411 void *pHwRef, 412 uint8_t *pEvent, 413 #ifdef ONE_BYTE_LEN 414 uint8_t length 415 #else 416 uint16_t length 417 #endif 418 ) 419 { 420 NFCSTATUS status = NFCSTATUS_SUCCESS; 421 phHciNfc_sContext_t *psHciContext = 422 (phHciNfc_sContext_t *)psContext ; 423 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pEvent) 424 || (0 == length)) 425 { 426 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 427 } 428 else if(NULL == psHciContext->p_nfcip_info) 429 { 430 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 431 } 432 else 433 { 434 phHciNfc_HCP_Packet_t *p_packet = NULL; 435 phHciNfc_NfcIP_Info_t *p_nfcip_info=NULL; 436 phHciNfc_HCP_Message_t *message = NULL; 437 uint8_t instruction=0; 438 439 p_nfcip_info = (phHciNfc_NfcIP_Info_t *) 440 psHciContext->p_nfcip_info ; 441 p_packet = (phHciNfc_HCP_Packet_t *)pEvent; 442 message = &p_packet->msg.message; 443 /* Get the instruction bits from the Message Header */ 444 instruction = (uint8_t) GET_BITS8( message->msg_header, 445 HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN); 446 if (NXP_EVT_NFC_ACTIVATED == instruction) 447 { 448 p_nfcip_info->nfcip_type = NFCIP_INITIATOR; 449 psHciContext->host_rf_type = phHal_eNfcIP1_Initiator; 450 p_nfcip_info->rem_nfcip_tgt_info.RemDevType = phHal_eNfcIP1_Target; 451 } 452 453 status = phHciNfc_Recv_NfcIP_Event(psHciContext, 454 pHwRef, pEvent, length); 455 } 456 return status; 457 } 458 459 NFCSTATUS 460 phHciNfc_Target_Init_Resources( 461 phHciNfc_sContext_t *psHciContext 462 ) 463 { 464 NFCSTATUS status = NFCSTATUS_SUCCESS; 465 phHciNfc_NfcIP_Info_t *p_target_info=NULL; 466 if( NULL == psHciContext ) 467 { 468 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 469 } 470 else 471 { 472 if (NULL != psHciContext->p_nfcip_info) 473 { 474 status = NFCSTATUS_SUCCESS; 475 } 476 else if( 477 ( NULL == psHciContext->p_nfcip_info ) && 478 (phHciNfc_Allocate_Resource((void **)(&p_target_info), 479 sizeof(phHciNfc_NfcIP_Info_t))== NFCSTATUS_SUCCESS) 480 ) 481 { 482 psHciContext->p_nfcip_info = p_target_info; 483 p_target_info->nfcip_type = NFCIP_INVALID; 484 p_target_info->current_seq = NFCIP_INVALID_SEQUENCE; 485 p_target_info->next_seq = NFCIP_INVALID_SEQUENCE; 486 p_target_info->p_tgt_pipe_info = NULL; 487 p_target_info->p_tgt_pipe_info = NULL; 488 } 489 else 490 { 491 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES); 492 } 493 494 } 495 return status; 496 } 497 498 NFCSTATUS 499 phHciNfc_Target_Get_PipeID( 500 phHciNfc_sContext_t *psHciContext, 501 uint8_t *ppipe_id 502 ) 503 { 504 NFCSTATUS status = NFCSTATUS_SUCCESS; 505 if( (NULL != psHciContext) 506 && ( NULL != ppipe_id ) 507 && ( NULL != psHciContext->p_nfcip_info ) 508 ) 509 { 510 phHciNfc_NfcIP_Info_t *p_target_info=NULL; 511 p_target_info = (phHciNfc_NfcIP_Info_t *) 512 psHciContext->p_nfcip_info ; 513 *ppipe_id = p_target_info->p_tgt_pipe_info->pipe.pipe_id; 514 } 515 else 516 { 517 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 518 } 519 return status; 520 } 521 522 NFCSTATUS 523 phHciNfc_Target_Update_PipeInfo( 524 phHciNfc_sContext_t *psHciContext, 525 uint8_t pipeID, 526 phHciNfc_Pipe_Info_t *pPipeInfo 527 ) 528 { 529 NFCSTATUS status = NFCSTATUS_SUCCESS; 530 if( NULL == psHciContext ) 531 { 532 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 533 } 534 else if(NULL == psHciContext->p_nfcip_info) 535 { 536 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 537 } 538 else 539 { 540 phHciNfc_NfcIP_Info_t *p_target_info=NULL; 541 p_target_info = (phHciNfc_NfcIP_Info_t *) 542 psHciContext->p_nfcip_info ; 543 /* Update the pipe_id of the NFCIP-1 target Gate obtained from 544 the HCI Response */ 545 p_target_info->p_tgt_pipe_info = pPipeInfo; 546 p_target_info->p_tgt_pipe_info->pipe.pipe_id = pipeID; 547 /* Update the Response Receive routine of the NFCIP-1 target Gate */ 548 pPipeInfo->recv_resp = &phHciNfc_Recv_Target_Response; 549 /* Update the event Receive routine of the NFCIP-1 target Gate */ 550 pPipeInfo->recv_event = &phHciNfc_Recv_Target_Event; 551 } 552 return status; 553 } 554 555 static 556 NFCSTATUS 557 phHciNfc_Recv_Target_Response( 558 void *pContext, 559 void *pHwRef, 560 uint8_t *pResponse, 561 #ifdef ONE_BYTE_LEN 562 uint8_t length 563 #else 564 uint16_t length 565 #endif 566 ) 567 { 568 NFCSTATUS status = NFCSTATUS_SUCCESS; 569 phHciNfc_sContext_t *psHciContext = 570 (phHciNfc_sContext_t *)pContext ; 571 572 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse) 573 || (0 == length)) 574 { 575 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 576 } 577 else if(NULL == psHciContext->p_nfcip_info) 578 { 579 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 580 } 581 else 582 { 583 phHciNfc_NfcIP_Info_t *p_nfcip_info=NULL; 584 phHciNfc_Pipe_Info_t *p_pipe_info = NULL; 585 586 p_nfcip_info = (phHciNfc_NfcIP_Info_t *) 587 psHciContext->p_nfcip_info ; 588 p_pipe_info = p_nfcip_info->p_tgt_pipe_info; 589 if( NULL == p_pipe_info) 590 { 591 status = PHNFCSTVAL(CID_NFC_HCI, 592 NFCSTATUS_INVALID_HCI_INFORMATION); 593 } 594 else 595 { 596 status = phHciNfc_Recv_NfcIP_Response(psHciContext, 597 p_pipe_info, pResponse, 598 length); 599 if (NFCSTATUS_SUCCESS == status) 600 { 601 status = phHciNfc_EmuMgmt_Update_Seq(psHciContext, 602 UPDATE_SEQ); 603 } 604 } 605 } 606 return status; 607 } 608 609 static 610 NFCSTATUS 611 phHciNfc_Recv_Target_Event( 612 void *psContext, 613 void *pHwRef, 614 uint8_t *pEvent, 615 #ifdef ONE_BYTE_LEN 616 uint8_t length 617 #else 618 uint16_t length 619 #endif 620 ) 621 { 622 NFCSTATUS status = NFCSTATUS_SUCCESS; 623 phHciNfc_sContext_t *psHciContext = 624 (phHciNfc_sContext_t *)psContext ; 625 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pEvent) 626 || (0 == length)) 627 { 628 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 629 } 630 else if(NULL == psHciContext->p_nfcip_info) 631 { 632 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 633 } 634 else 635 { 636 phHciNfc_HCP_Packet_t *p_packet = NULL; 637 phHciNfc_NfcIP_Info_t *p_nfcip_info=NULL; 638 phHciNfc_HCP_Message_t *message = NULL; 639 uint8_t instruction=0; 640 641 p_nfcip_info = (phHciNfc_NfcIP_Info_t *)psHciContext->p_nfcip_info ; 642 p_packet = (phHciNfc_HCP_Packet_t *)pEvent; 643 message = &p_packet->msg.message; 644 /* Get the instruction bits from the Message Header */ 645 instruction = (uint8_t) GET_BITS8( message->msg_header, 646 HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN); 647 if (NXP_EVT_NFC_ACTIVATED == instruction) 648 { 649 p_nfcip_info->nfcip_type = NFCIP_TARGET; 650 psHciContext->host_rf_type = phHal_eNfcIP1_Target; 651 p_nfcip_info->rem_nfcip_tgt_info.RemDevType = 652 phHal_eNfcIP1_Initiator; 653 } 654 status = phHciNfc_Recv_NfcIP_Event(psHciContext, 655 pHwRef, pEvent, length); 656 } 657 return status; 658 } 659 660 static 661 NFCSTATUS 662 phHciNfc_Recv_NfcIP_Response( 663 phHciNfc_sContext_t *psHciContext, 664 phHciNfc_Pipe_Info_t *ppipe_info, 665 uint8_t *pResponse, 666 #ifdef ONE_BYTE_LEN 667 uint8_t length 668 #else 669 uint16_t length 670 #endif 671 ) 672 { 673 NFCSTATUS status = NFCSTATUS_SUCCESS; 674 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 675 uint8_t prev_cmd = ANY_GET_PARAMETER; 676 677 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 678 psHciContext->p_nfcip_info ; 679 prev_cmd = ppipe_info->prev_msg ; 680 switch(prev_cmd) 681 { 682 case ANY_OPEN_PIPE: 683 { 684 HCI_PRINT("NFCIP-1 NFCIP open pipe complete\n"); 685 p_nfcipinfo->next_seq = NFCIP_NFCID3I; 686 break; 687 } 688 case ANY_CLOSE_PIPE: 689 { 690 HCI_PRINT("NFCIP-1 NFCIP close pipe complete\n"); 691 p_nfcipinfo->next_seq = NFCIP_NFCID3I; 692 break; 693 } 694 case ANY_GET_PARAMETER: 695 { 696 HCI_PRINT("NFCIP-1 NFCIP get parameter complete\n"); 697 if (length >= HCP_HEADER_LEN) 698 { 699 status = phHciNfc_NfcIP_InfoUpdate(psHciContext, 700 ppipe_info->reg_index, 701 &pResponse[HCP_HEADER_LEN], 702 (uint8_t)(length - HCP_HEADER_LEN)); 703 } 704 else 705 { 706 status = PHNFCSTVAL(CID_NFC_HCI, 707 NFCSTATUS_INVALID_HCI_RESPONSE); 708 } 709 break; 710 } 711 case ANY_SET_PARAMETER: 712 { 713 HCI_PRINT("NFCIP-1 NFCIP Parameter Set \n"); 714 p_nfcipinfo->next_seq = NFCIP_NFCID3I; 715 break; 716 } 717 case NXP_NFCI_CONTINUE_ACTIVATION: 718 case NXP_NFCIP_ATTREQUEST: 719 { 720 p_nfcipinfo->next_seq = NFCIP_NFCID3I; 721 break; 722 } 723 default: 724 { 725 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE); 726 break; 727 } 728 } 729 730 if( NFCSTATUS_SUCCESS == status ) 731 { 732 ppipe_info->prev_status = NFCSTATUS_SUCCESS; 733 p_nfcipinfo->current_seq = p_nfcipinfo->next_seq; 734 } 735 return status; 736 } 737 738 static 739 NFCSTATUS 740 phHciNfc_Recv_NfcIP_Event( 741 phHciNfc_sContext_t *psHciContext, 742 void *pHwRef, 743 uint8_t *pEvent, 744 #ifdef ONE_BYTE_LEN 745 uint8_t length 746 #else 747 uint16_t length 748 #endif 749 ) 750 { 751 NFCSTATUS status = NFCSTATUS_SUCCESS; 752 phHciNfc_HCP_Packet_t *p_packet = NULL; 753 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 754 phHciNfc_HCP_Message_t *message = NULL; 755 phNfc_sCompletionInfo_t pCompInfo; 756 uint8_t instruction=0; 757 uint8_t type = 0; 758 759 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 760 psHciContext->p_nfcip_info ; 761 p_packet = (phHciNfc_HCP_Packet_t *)pEvent; 762 message = &p_packet->msg.message; 763 /* Get the instruction bits from the Message Header */ 764 instruction = (uint8_t) GET_BITS8( message->msg_header, 765 HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN); 766 767 switch(instruction) 768 { 769 case NXP_EVT_NFC_ACTIVATED: 770 { 771 HCI_PRINT("NFCIP-1 device discovered\n"); 772 773 if (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type) 774 { 775 pCompInfo.info = &(p_nfcipinfo->rem_nfcip_tgt_info); 776 type = NFC_NOTIFY_TARGET_DISCOVERED; 777 } 778 else 779 { 780 type = NFC_NOTIFY_DEVICE_ACTIVATED; 781 } 782 783 if(length > HCP_HEADER_LEN) 784 { 785 HCI_DEBUG("NfcIP-1 activation mode : %d\n", pEvent[HCP_HEADER_LEN]); 786 /* Mode indicates in which mode the current activation 787 as be done 788 - 0x00: Passive mode 789 - 0x01: Active */ 790 p_nfcipinfo->activation_mode = pEvent[HCP_HEADER_LEN]; 791 } 792 pCompInfo.status = NFCSTATUS_SUCCESS; 793 /* Notify to the HCI Generic layer To Update the FSM */ 794 phHciNfc_Notify_Event(psHciContext, pHwRef, 795 type, &pCompInfo); 796 break; 797 } 798 case NXP_EVT_NFC_DEACTIVATED: 799 { 800 static phHal_sEventInfo_t event_info; 801 802 event_info.eventHost = phHal_eHostController; 803 event_info.eventType = NFC_EVT_DEACTIVATED; 804 p_nfcipinfo->activation_mode = FALSE; 805 if (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type) 806 { 807 p_nfcipinfo->rem_nfcip_tgt_info.RemDevType = 808 phHal_eNfcIP1_Target; 809 event_info.eventSource = phHal_eNfcIP1_Initiator; 810 } 811 else 812 { 813 p_nfcipinfo->rem_nfcip_tgt_info.RemDevType = 814 phHal_eNfcIP1_Initiator; 815 event_info.eventSource = phHal_eNfcIP1_Target; 816 } 817 /* Reset the sequence */ 818 p_nfcipinfo->current_seq = NFCIP_NFCID3I; 819 p_nfcipinfo->next_seq = NFCIP_NFCID3I; 820 821 HCI_PRINT("NFCIP-1 Target Deactivated\n"); 822 phHciNfc_Notify_Event(psHciContext, pHwRef, 823 NFC_NOTIFY_DEVICE_DEACTIVATED, 824 &event_info); 825 break; 826 } 827 case NXP_EVT_NFC_RCV_DATA: 828 { 829 status = phHciNfc_NfcIP_RecvData(psHciContext, 830 pHwRef, 831 &pEvent[HCP_HEADER_LEN], 832 (length - HCP_HEADER_LEN)); 833 break; 834 } 835 case NXP_EVT_NFC_CONTINUE_MI: 836 { 837 /* psHciContext->response_pending = FALSE; */ 838 psHciContext->event_pending = FALSE; 839 break; 840 } 841 default: 842 { 843 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 844 break; 845 } 846 } 847 848 return status; 849 } 850 851 static 852 NFCSTATUS 853 phHciNfc_NfcIP_RecvData( 854 phHciNfc_sContext_t *psHciContext, 855 void *pHwRef, 856 uint8_t *pResponse, 857 #ifdef ONE_BYTE_LEN 858 uint8_t length 859 #else 860 uint16_t length 861 #endif 862 ) 863 { 864 NFCSTATUS status = NFCSTATUS_SUCCESS; 865 uint8_t index = 0; 866 867 if( (NULL == psHciContext) 868 || (NULL == pHwRef) 869 || (NULL == pResponse) 870 || (0 == length)) 871 { 872 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 873 } 874 else 875 { 876 phNfc_sTransactionInfo_t transInfo; 877 phHciNfc_NfcIP_Info_t *p_nfcipinfo = NULL; 878 uint8_t type = 0; 879 880 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 881 psHciContext->p_nfcip_info; 882 HCI_PRINT("NFCIP-1 received bytes :"); 883 if (NFCIP_RF_NO_ERROR == pResponse[index]) 884 { 885 HCI_PRINT_BUFFER("device ", &pResponse[index], (length - index)); 886 transInfo.status = NFCSTATUS_SUCCESS; 887 index++; 888 if (TRUE == pResponse[index]) 889 { 890 /* Update the more information bit to the upper layer */ 891 transInfo.status = NFCSTATUS_MORE_INFORMATION; 892 } 893 index++; 894 895 896 transInfo.buffer = &pResponse[index]; 897 transInfo.length = (length - index); 898 type = (uint8_t)NFC_NOTIFY_RECV_EVENT; 899 } 900 else 901 { 902 HCI_PRINT("NFCIP-1 receive RF ERROR "); 903 p_nfcipinfo->activation_mode = FALSE; 904 type = (uint8_t)NFC_NOTIFY_RECV_EVENT; 905 transInfo.status = NFCSTATUS_RF_TIMEOUT; 906 transInfo.buffer = NULL; 907 transInfo.length = 0; 908 } 909 status = NFCSTATUS_PENDING; 910 /* Event NXP_EVT_NFC_RCV_DATA: so give received data to 911 the upper layer */ 912 phHciNfc_Notify_Event(psHciContext, pHwRef, 913 type, 914 &transInfo ); 915 } 916 return status; 917 } 918 919 NFCSTATUS 920 phHciNfc_NfcIP_Send_Data ( 921 phHciNfc_sContext_t *psHciContext, 922 void *pHwRef, 923 phHciNfc_XchgInfo_t *sData 924 ) 925 { 926 NFCSTATUS status = NFCSTATUS_SUCCESS; 927 928 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == sData) || 929 (NULL == sData->tx_buffer) || (0 == sData->tx_length)) 930 { 931 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 932 } 933 else if((NULL == psHciContext->p_nfcip_info) || 934 (NFCIP_INVALID == 935 ((phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info))->nfcip_type)) 936 { 937 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 938 } 939 else 940 { 941 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 942 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 943 944 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 945 psHciContext->p_nfcip_info ; 946 p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)? 947 p_nfcipinfo->p_init_pipe_info : 948 p_nfcipinfo->p_tgt_pipe_info); 949 950 if(NULL == p_pipe_info ) 951 { 952 status = PHNFCSTVAL(CID_NFC_HCI, 953 NFCSTATUS_INVALID_HCI_INFORMATION); 954 } 955 else 956 { 957 phHciNfc_HCP_Packet_t *hcp_packet = NULL; 958 phHciNfc_HCP_Message_t *hcp_message = NULL; 959 uint16_t length = HCP_HEADER_LEN; 960 uint8_t pipeid = 0, 961 i = 0; 962 963 HCI_PRINT_BUFFER("HCI NFCIP-1 Send Data: ", sData->tx_buffer, sData->tx_length); 964 965 psHciContext->tx_total = 0 ; 966 pipeid = p_pipe_info->pipe.pipe_id; 967 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer; 968 hcp_message = &(hcp_packet->msg.message); 969 hcp_message->payload[i] = sData->params.nfc_info.more_info; 970 i++; 971 972 /* Construct the HCP Frame */ 973 phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT, 974 (uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_EVENT, 975 (uint8_t)NXP_EVT_NFC_SND_DATA); 976 977 phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload, 978 i, (uint8_t *)sData->tx_buffer, 979 (uint8_t)sData->tx_length); 980 981 length =(uint16_t)(length + i + sData->tx_length); 982 983 p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_EVENT; 984 p_pipe_info->prev_msg = NXP_EVT_NFC_SND_DATA; 985 psHciContext->tx_total = length; 986 /* Send the Constructed HCP packet to the lower layer */ 987 status = phHciNfc_Send_HCP( psHciContext, pHwRef); 988 #if !defined (ENABLE_CONTINUE_MI) 989 if ((TRUE == sData->params.nfc_info.more_info) && 990 (NFCSTATUS_PENDING == status)) 991 { 992 /* If more information bit is set, then wait for the event 993 NXP_EVT_NFC_CONTINUE_MI */ 994 /* psHciContext->response_pending = TRUE; */ 995 psHciContext->event_pending = TRUE; 996 } 997 #endif /* #if defined (ENABLE_CONTINUE_MI) */ 998 p_pipe_info->prev_status = status; 999 } 1000 } 1001 return status; 1002 } 1003 1004 NFCSTATUS 1005 phHciNfc_NfcIP_Info_Sequence ( 1006 phHciNfc_sContext_t *psHciContext, 1007 void *pHwRef 1008 #ifdef NOTIFY_REQD 1009 , 1010 uint8_t notify_reqd 1011 #endif /* #ifdef NOTIFY_REQD */ 1012 ) 1013 { 1014 NFCSTATUS status = NFCSTATUS_SUCCESS; 1015 1016 if( (NULL == psHciContext) 1017 || (NULL == pHwRef) 1018 ) 1019 { 1020 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1021 } 1022 else if((NULL == psHciContext->p_nfcip_info) || 1023 (NFCIP_INVALID == 1024 ((phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info))-> 1025 nfcip_type)) 1026 { 1027 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 1028 } 1029 else 1030 { 1031 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 1032 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 1033 1034 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 1035 psHciContext->p_nfcip_info ; 1036 p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)? 1037 p_nfcipinfo->p_init_pipe_info: 1038 p_nfcipinfo->p_tgt_pipe_info); 1039 if(NULL == p_pipe_info ) 1040 { 1041 status = PHNFCSTVAL(CID_NFC_HCI, 1042 NFCSTATUS_INVALID_HCI_INFORMATION); 1043 } 1044 else 1045 { 1046 switch(p_nfcipinfo->current_seq) 1047 { 1048 case NFCIP_NFCID3I: 1049 { 1050 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_NFCID3I; 1051 /* Fill the data buffer and send the command to the 1052 device */ 1053 status = 1054 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1055 p_pipe_info->pipe.pipe_id, 1056 ANY_GET_PARAMETER); 1057 if(NFCSTATUS_PENDING == status ) 1058 { 1059 p_nfcipinfo->next_seq = NFCIP_NFCID3T; 1060 } 1061 break; 1062 } 1063 case NFCIP_NFCID3T: 1064 { 1065 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_NFCID3T; 1066 /* Fill the data buffer and send the command to the 1067 device */ 1068 status = 1069 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1070 p_pipe_info->pipe.pipe_id, 1071 ANY_GET_PARAMETER); 1072 if(NFCSTATUS_PENDING == status ) 1073 { 1074 p_nfcipinfo->next_seq = NFCIP_PARAM; 1075 } 1076 break; 1077 } 1078 case NFCIP_PARAM: 1079 { 1080 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PARAM; 1081 /* Fill the data buffer and send the command to the 1082 device */ 1083 status = 1084 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1085 p_pipe_info->pipe.pipe_id, 1086 ANY_GET_PARAMETER); 1087 if(NFCSTATUS_PENDING == status ) 1088 { 1089 p_nfcipinfo->next_seq = NFCIP_ATR_INFO; 1090 } 1091 break; 1092 } 1093 case NFCIP_ATR_INFO: 1094 { 1095 p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR == 1096 p_nfcipinfo->nfcip_type)? 1097 NXP_NFCIP_ATR_RES : 1098 NXP_NFCIP_ATR_REQ); 1099 status = 1100 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1101 p_pipe_info->pipe.pipe_id, 1102 ANY_GET_PARAMETER); 1103 1104 if(NFCSTATUS_PENDING == status ) 1105 { 1106 p_nfcipinfo->next_seq = NFCIP_STATUS; 1107 } 1108 break; 1109 } 1110 case NFCIP_STATUS: 1111 { 1112 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_STATUS; 1113 /* Fill the data buffer and send the command to the 1114 device */ 1115 status = 1116 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1117 p_pipe_info->pipe.pipe_id, 1118 ANY_GET_PARAMETER); 1119 if(NFCSTATUS_PENDING == status ) 1120 { 1121 #ifdef NOTIFY_REQD 1122 if(FALSE == notify_reqd) 1123 #else /* #ifdef NOTIFY_REQD */ 1124 if (NULL != psHciContext->p_target_info) 1125 #endif /* #ifdef NOTIFY_REQD */ 1126 { 1127 p_nfcipinfo->next_seq = NFCIP_NFCID3I; 1128 status = NFCSTATUS_SUCCESS; 1129 } 1130 else 1131 { 1132 p_nfcipinfo->next_seq = NFCIP_END_SEQUENCE; 1133 } 1134 } 1135 break; 1136 } 1137 case NFCIP_END_SEQUENCE: 1138 { 1139 phHal_uRemoteDevInfo_t *rem_nfcipinfo = NULL; 1140 1141 if (NULL != psHciContext->p_target_info) 1142 { 1143 /* This is given to user */ 1144 rem_nfcipinfo = 1145 &(psHciContext->p_target_info->RemoteDevInfo); 1146 } 1147 else 1148 { 1149 rem_nfcipinfo = 1150 &(p_nfcipinfo->rem_nfcip_tgt_info.RemoteDevInfo); 1151 } 1152 1153 /* Update maximum frame length */ 1154 rem_nfcipinfo->NfcIP_Info.MaxFrameLength = 1155 p_nfcipinfo->max_frame_len; 1156 1157 p_nfcipinfo->current_seq = NFCIP_NFCID3I; 1158 p_nfcipinfo->next_seq = NFCIP_NFCID3I; 1159 1160 rem_nfcipinfo->NfcIP_Info.Nfcip_Active = 1161 p_nfcipinfo->activation_mode; 1162 1163 1164 if (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type) 1165 { 1166 phNfc_sCompletionInfo_t CompInfo; 1167 1168 p_nfcipinfo->rem_nfcip_tgt_info.RemDevType = 1169 phHal_eNfcIP1_Target; 1170 1171 /* Update initiator speed */ 1172 rem_nfcipinfo->NfcIP_Info.Nfcip_Datarate = 1173 (phHalNfc_eDataRate_t) 1174 (p_nfcipinfo->initiator_speed); 1175 1176 1177 /* Update ATR info */ 1178 rem_nfcipinfo->NfcIP_Info.ATRInfo_Length = 1179 p_nfcipinfo->atr_res_length; 1180 (void)memcpy( 1181 (void *)rem_nfcipinfo->NfcIP_Info.ATRInfo, 1182 (void *)p_nfcipinfo->atr_res_info, 1183 rem_nfcipinfo->NfcIP_Info.ATRInfo_Length); 1184 1185 /* Update NFCID */ 1186 rem_nfcipinfo->NfcIP_Info.NFCID_Length = 1187 p_nfcipinfo->nfcid3i_length; 1188 (void)memcpy( 1189 (void *)rem_nfcipinfo->NfcIP_Info.NFCID, 1190 (void *)p_nfcipinfo->nfcid3i, 1191 rem_nfcipinfo->NfcIP_Info.NFCID_Length); 1192 1193 CompInfo.status = status = NFCSTATUS_SUCCESS; 1194 if (NULL != psHciContext->p_target_info) 1195 { 1196 CompInfo.info = &(psHciContext->p_target_info); 1197 } 1198 else 1199 { 1200 CompInfo.info = &(p_nfcipinfo->rem_nfcip_tgt_info); 1201 } 1202 /* Notify to the upper layer */ 1203 phHciNfc_Tag_Notify(psHciContext, pHwRef, 1204 NFC_NOTIFY_TARGET_DISCOVERED, 1205 &CompInfo); 1206 } 1207 else 1208 { 1209 static phHal_sEventInfo_t event_info; 1210 1211 p_nfcipinfo->rem_nfcip_tgt_info.RemDevType = 1212 phHal_eNfcIP1_Initiator; 1213 1214 /* Update target speed */ 1215 rem_nfcipinfo->NfcIP_Info.Nfcip_Datarate = 1216 (phHalNfc_eDataRate_t) 1217 (p_nfcipinfo->target_speed); 1218 /* Update ATR info */ 1219 rem_nfcipinfo->NfcIP_Info.ATRInfo_Length = 1220 p_nfcipinfo->atr_req_length; 1221 (void)memcpy( 1222 (void *)rem_nfcipinfo->NfcIP_Info.ATRInfo, 1223 (void *)p_nfcipinfo->atr_req_info, 1224 rem_nfcipinfo->NfcIP_Info.ATRInfo_Length); 1225 1226 /* Update NFCID */ 1227 rem_nfcipinfo->NfcIP_Info.NFCID_Length = 1228 p_nfcipinfo->nfcid3t_length; 1229 (void)memcpy( 1230 (void *)rem_nfcipinfo->NfcIP_Info.NFCID, 1231 (void *)p_nfcipinfo->nfcid3t, 1232 rem_nfcipinfo->NfcIP_Info.NFCID_Length); 1233 1234 event_info.eventHost = phHal_eHostController; 1235 event_info.eventType = NFC_EVT_ACTIVATED; 1236 event_info.eventSource = phHal_eNfcIP1_Target; 1237 event_info.eventInfo.pRemoteDevInfo = 1238 &(p_nfcipinfo->rem_nfcip_tgt_info); 1239 1240 phHciNfc_Target_Select_Notify((void *)psHciContext, 1241 pHwRef, 1242 NFC_NOTIFY_EVENT, 1243 &(event_info)); 1244 } 1245 break; 1246 } 1247 default: 1248 { 1249 status = PHNFCSTVAL(CID_NFC_HCI, 1250 NFCSTATUS_INVALID_HCI_RESPONSE); 1251 break; 1252 } 1253 } 1254 } 1255 } 1256 return status; 1257 } 1258 1259 static 1260 NFCSTATUS 1261 phHciNfc_NfcIP_InfoUpdate( 1262 phHciNfc_sContext_t *psHciContext, 1263 uint8_t index, 1264 uint8_t *reg_value, 1265 uint8_t reg_length 1266 ) 1267 { 1268 NFCSTATUS status = NFCSTATUS_SUCCESS; 1269 phHciNfc_NfcIP_Info_t *p_nfcipinfo = NULL; 1270 phHal_sNfcIPInfo_t *p_rem_nfcipinfo = NULL; 1271 1272 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info ); 1273 p_rem_nfcipinfo = &(p_nfcipinfo->rem_nfcip_tgt_info.RemoteDevInfo.NfcIP_Info); 1274 1275 1276 switch(index) 1277 { 1278 case NXP_NFCIP_ATR_RES: 1279 { 1280 if (reg_length <= NFCIP_ATR_MAX_LENGTH) 1281 { 1282 /* Remote device info provided by the user */ 1283 1284 HCI_PRINT_BUFFER("\tNFCIP ATR_RES", reg_value, reg_length); 1285 1286 p_rem_nfcipinfo->ATRInfo_Length = 1287 p_nfcipinfo->atr_res_length = reg_length; 1288 1289 (void)memcpy((void *)p_rem_nfcipinfo->ATRInfo, 1290 (void *)reg_value, 1291 p_rem_nfcipinfo->ATRInfo_Length); 1292 1293 (void)memcpy((void *)p_nfcipinfo->atr_res_info, 1294 (void *)reg_value, 1295 p_nfcipinfo->atr_res_length); 1296 if (NULL != psHciContext->p_target_info) 1297 { 1298 phHal_sNfcIPInfo_t *p_remtgt_info = NULL; 1299 /* This is given to user */ 1300 p_remtgt_info = 1301 &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info); 1302 p_remtgt_info->ATRInfo_Length = reg_length; 1303 (void)memcpy((void *)p_remtgt_info->ATRInfo, 1304 (void *)reg_value, 1305 p_remtgt_info->ATRInfo_Length); 1306 } 1307 } 1308 else 1309 { 1310 status = PHNFCSTVAL(CID_NFC_HCI, 1311 NFCSTATUS_INVALID_HCI_RESPONSE); 1312 } 1313 break; 1314 } 1315 case NXP_NFCIP_STATUS: 1316 { 1317 if (sizeof(*reg_value) == reg_length) 1318 #ifdef STATUS_BUFFER_CHECK 1319 && (*reg_value <= NFCIP_STATUS_MAX_VALUE)) 1320 #endif /* #ifdef STATUS_ERROR */ 1321 { 1322 HCI_PRINT_BUFFER("\tNFCIP STATUS", reg_value, reg_length); 1323 p_nfcipinfo->linkstatus = *reg_value; 1324 } 1325 else 1326 { 1327 status = PHNFCSTVAL(CID_NFC_HCI, 1328 NFCSTATUS_INVALID_HCI_RESPONSE); 1329 } 1330 break; 1331 } 1332 case NXP_NFCIP_NFCID3I: 1333 { 1334 if (reg_length <= NFCIP_NFCID_LENGTH) 1335 { 1336 HCI_PRINT_BUFFER("\tNFCIP NFCID3I", reg_value, reg_length); 1337 p_nfcipinfo->nfcid3i_length = 1338 p_rem_nfcipinfo->NFCID_Length = reg_length; 1339 (void)memcpy((void *)p_rem_nfcipinfo->NFCID, 1340 (void *)reg_value, 1341 p_rem_nfcipinfo->NFCID_Length); 1342 (void)memcpy((void *)p_nfcipinfo->nfcid3i, 1343 (void *)reg_value, 1344 reg_length); 1345 if ((NULL != psHciContext->p_target_info) && 1346 (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)) 1347 { 1348 phHal_sNfcIPInfo_t *p_remtgt_info = NULL; 1349 /* This is given to user */ 1350 p_remtgt_info = 1351 &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info); 1352 p_remtgt_info->NFCID_Length = reg_length; 1353 (void)memcpy((void *)p_remtgt_info->NFCID, 1354 (void *)reg_value, 1355 p_remtgt_info->NFCID_Length); 1356 } 1357 } 1358 else 1359 { 1360 status = PHNFCSTVAL(CID_NFC_HCI, 1361 NFCSTATUS_INVALID_HCI_RESPONSE); 1362 } 1363 break; 1364 } 1365 case NXP_NFCIP_NFCID3T: 1366 { 1367 if (reg_length <= NFCIP_NFCID_LENGTH) 1368 { 1369 HCI_PRINT_BUFFER("\tNFCIP NFCID3T", reg_value, reg_length); 1370 p_nfcipinfo->nfcid3t_length = 1371 p_rem_nfcipinfo->NFCID_Length = reg_length; 1372 (void)memcpy((void *)p_rem_nfcipinfo->NFCID, 1373 (void *)reg_value, 1374 p_rem_nfcipinfo->NFCID_Length); 1375 (void)memcpy((void *)p_nfcipinfo->nfcid3t, 1376 (void *)reg_value, 1377 reg_length); 1378 if ((NULL != psHciContext->p_target_info) && 1379 (NFCIP_TARGET == p_nfcipinfo->nfcip_type)) 1380 { 1381 phHal_sNfcIPInfo_t *p_remtgt_info = NULL; 1382 /* This is given to user */ 1383 p_remtgt_info = 1384 &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info); 1385 p_remtgt_info->NFCID_Length = reg_length; 1386 (void)memcpy((void *)p_remtgt_info->NFCID, 1387 (void *)reg_value, 1388 p_remtgt_info->NFCID_Length); 1389 } 1390 } 1391 else 1392 { 1393 status = PHNFCSTVAL(CID_NFC_HCI, 1394 NFCSTATUS_INVALID_HCI_RESPONSE); 1395 } 1396 break; 1397 } 1398 case NXP_NFCIP_PARAM: 1399 { 1400 if (sizeof(*reg_value) == reg_length) 1401 { 1402 HCI_PRINT_BUFFER("\tNFCIP PARAMS", reg_value, reg_length); 1403 p_nfcipinfo->initiator_speed = (phHciNfc_eP2PSpeed_t) 1404 ((*reg_value >> NFCIP_COMM_INITIATOR_SHIFT) 1405 & NFCIP_COMM_FACTOR); 1406 p_nfcipinfo->target_speed = (phHciNfc_eP2PSpeed_t) 1407 (*reg_value & NFCIP_COMM_FACTOR); 1408 p_nfcipinfo->max_frame_len = NFCIP_DATA_RATE_CALC(*reg_value); 1409 1410 if (NULL != psHciContext->p_target_info) 1411 { 1412 phHal_sNfcIPInfo_t *p_remtgt_info = NULL; 1413 /* This is given to user */ 1414 p_remtgt_info = 1415 &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info); 1416 p_remtgt_info->MaxFrameLength = p_nfcipinfo->max_frame_len; 1417 p_remtgt_info->Nfcip_Datarate = (phHalNfc_eDataRate_t) 1418 p_nfcipinfo->initiator_speed; 1419 } 1420 } 1421 else 1422 { 1423 status = PHNFCSTVAL(CID_NFC_HCI, 1424 NFCSTATUS_INVALID_HCI_RESPONSE); 1425 } 1426 break; 1427 } 1428 case NXP_NFCIP_MODE: 1429 { 1430 if (sizeof(*reg_value) == reg_length) 1431 { 1432 HCI_PRINT_BUFFER("\tNFCIP MODE", reg_value, reg_length); 1433 p_nfcipinfo->nfcip_mode = *reg_value; 1434 } 1435 else 1436 { 1437 status = PHNFCSTVAL(CID_NFC_HCI, 1438 NFCSTATUS_INVALID_HCI_RESPONSE); 1439 } 1440 break; 1441 } 1442 case NXP_NFCIP_ATR_REQ: 1443 { 1444 if (reg_length <= NFCIP_ATR_MAX_LENGTH) 1445 { 1446 HCI_PRINT_BUFFER("\tNFCIP ATR_REQ", reg_value, reg_length); 1447 p_rem_nfcipinfo->ATRInfo_Length = 1448 p_nfcipinfo->atr_req_length = reg_length; 1449 (void)memcpy((void *)p_rem_nfcipinfo->ATRInfo, 1450 (void *)reg_value, 1451 p_rem_nfcipinfo->ATRInfo_Length); 1452 (void)memcpy((void *)p_nfcipinfo->atr_req_info, 1453 (void *)reg_value, 1454 p_nfcipinfo->atr_req_length); 1455 if (NULL != psHciContext->p_target_info) 1456 { 1457 phHal_sNfcIPInfo_t *p_remtgt_info = NULL; 1458 /* This is given to user */ 1459 p_remtgt_info = 1460 &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info); 1461 p_remtgt_info->NFCID_Length = reg_length; 1462 (void)memcpy((void *)p_remtgt_info->ATRInfo, 1463 (void *)reg_value, 1464 p_remtgt_info->ATRInfo_Length); 1465 } 1466 } 1467 else 1468 { 1469 status = PHNFCSTVAL(CID_NFC_HCI, 1470 NFCSTATUS_INVALID_HCI_RESPONSE); 1471 } 1472 break; 1473 } 1474 case NXP_NFCIP_PSL1: 1475 { 1476 if (sizeof(*reg_value) == reg_length) 1477 { 1478 HCI_PRINT_BUFFER("\tNFCIP PSL1", reg_value, reg_length); 1479 p_nfcipinfo->psl1 = *reg_value; 1480 } 1481 else 1482 { 1483 status = PHNFCSTVAL(CID_NFC_HCI, 1484 NFCSTATUS_INVALID_HCI_RESPONSE); 1485 } 1486 break; 1487 } 1488 case NXP_NFCIP_PSL2: 1489 { 1490 if (sizeof(*reg_value) == reg_length) 1491 { 1492 HCI_PRINT_BUFFER("\tNFCIP PSL2", reg_value, reg_length); 1493 p_nfcipinfo->psl2 = *reg_value; 1494 } 1495 else 1496 { 1497 status = PHNFCSTVAL(CID_NFC_HCI, 1498 NFCSTATUS_INVALID_HCI_RESPONSE); 1499 } 1500 break; 1501 } 1502 case NXP_NFCIP_DID: 1503 { 1504 if (sizeof(*reg_value) == reg_length) 1505 { 1506 HCI_PRINT_BUFFER("\tNFCIP DID", reg_value, reg_length); 1507 p_nfcipinfo->did = *reg_value; 1508 } 1509 else 1510 { 1511 status = PHNFCSTVAL(CID_NFC_HCI, 1512 NFCSTATUS_INVALID_HCI_RESPONSE); 1513 } 1514 break; 1515 } 1516 case NXP_NFCIP_NAD: 1517 { 1518 if (sizeof(*reg_value) == reg_length) 1519 { 1520 HCI_PRINT_BUFFER("\tNFCIP NAD", reg_value, reg_length); 1521 p_nfcipinfo->nad = *reg_value; 1522 } 1523 else 1524 { 1525 status = PHNFCSTVAL(CID_NFC_HCI, 1526 NFCSTATUS_INVALID_HCI_RESPONSE); 1527 } 1528 break; 1529 } 1530 case NXP_NFCIP_OPTIONS: 1531 { 1532 if (sizeof(*reg_value) == reg_length) 1533 { 1534 HCI_PRINT_BUFFER("\tNFCIP OPTIONS", reg_value, reg_length); 1535 p_nfcipinfo->options = *reg_value; 1536 } 1537 else 1538 { 1539 status = PHNFCSTVAL(CID_NFC_HCI, 1540 NFCSTATUS_INVALID_HCI_RESPONSE); 1541 } 1542 break; 1543 } 1544 default: 1545 { 1546 status = PHNFCSTVAL(CID_NFC_HCI, 1547 NFCSTATUS_INVALID_HCI_RESPONSE); 1548 break; 1549 } 1550 } 1551 return status; 1552 } 1553 1554 1555 NFCSTATUS 1556 phHciNfc_NfcIP_SetMode( 1557 phHciNfc_sContext_t *psHciContext, 1558 void *pHwRef, 1559 phHciNfc_eNfcIPType_t nfciptype, 1560 uint8_t nfcip_mode 1561 ) 1562 { 1563 NFCSTATUS status = NFCSTATUS_SUCCESS; 1564 1565 if( (NULL == psHciContext) || (NULL == pHwRef) || 1566 (nfcip_mode > (uint8_t)NFCIP_MODE_ALL)) 1567 { 1568 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1569 } 1570 else if (NFCIP_INVALID == nfciptype) 1571 { 1572 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 1573 } 1574 else if(NULL == psHciContext->p_nfcip_info) 1575 { 1576 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 1577 } 1578 else 1579 { 1580 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 1581 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 1582 uint8_t pipeid = 0; 1583 1584 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 1585 psHciContext->p_nfcip_info ; 1586 p_pipe_info = ((NFCIP_INITIATOR == nfciptype)? 1587 p_nfcipinfo->p_init_pipe_info: 1588 p_nfcipinfo->p_tgt_pipe_info); 1589 1590 if(NULL == p_pipe_info ) 1591 { 1592 status = PHNFCSTVAL(CID_NFC_HCI, 1593 NFCSTATUS_INVALID_HCI_INFORMATION); 1594 } 1595 else 1596 { 1597 pipeid = p_pipe_info->pipe.pipe_id ; 1598 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_MODE; 1599 1600 p_pipe_info->param_info = &nfcip_mode; 1601 p_pipe_info->param_length = sizeof(uint8_t); 1602 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1603 pipeid, (uint8_t)ANY_SET_PARAMETER); 1604 } 1605 } 1606 return status; 1607 } 1608 1609 NFCSTATUS 1610 phHciNfc_NfcIP_SetNAD( 1611 phHciNfc_sContext_t *psHciContext, 1612 void *pHwRef, 1613 phHciNfc_eNfcIPType_t nfciptype, 1614 uint8_t nad 1615 ) 1616 { 1617 NFCSTATUS status = NFCSTATUS_SUCCESS; 1618 1619 if( (NULL == psHciContext) || (NULL == pHwRef)) 1620 { 1621 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1622 } 1623 else if (NFCIP_INVALID == nfciptype) 1624 { 1625 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 1626 } 1627 else if(NULL == psHciContext->p_nfcip_info) 1628 { 1629 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 1630 } 1631 else 1632 { 1633 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 1634 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 1635 uint8_t pipeid = 0; 1636 1637 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 1638 psHciContext->p_nfcip_info ; 1639 p_pipe_info = ((NFCIP_INITIATOR == nfciptype)? 1640 p_nfcipinfo->p_init_pipe_info: 1641 p_nfcipinfo->p_tgt_pipe_info); 1642 1643 if(NULL == p_pipe_info ) 1644 { 1645 status = PHNFCSTVAL(CID_NFC_HCI, 1646 NFCSTATUS_INVALID_HCI_INFORMATION); 1647 } 1648 else 1649 { 1650 pipeid = p_pipe_info->pipe.pipe_id ; 1651 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_NAD; 1652 1653 p_pipe_info->param_info = &nad; 1654 p_pipe_info->param_length = sizeof(uint8_t); 1655 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1656 pipeid, (uint8_t)ANY_SET_PARAMETER); 1657 } 1658 } 1659 return status; 1660 } 1661 1662 NFCSTATUS 1663 phHciNfc_NfcIP_SetDID( 1664 phHciNfc_sContext_t *psHciContext, 1665 void *pHwRef, 1666 uint8_t did 1667 ) 1668 { 1669 NFCSTATUS status = NFCSTATUS_SUCCESS; 1670 1671 if( (NULL == psHciContext) || (NULL == pHwRef)) 1672 { 1673 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1674 } 1675 else if(NULL == psHciContext->p_nfcip_info) 1676 { 1677 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 1678 } 1679 else 1680 { 1681 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 1682 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 1683 uint8_t pipeid = 0; 1684 1685 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 1686 psHciContext->p_nfcip_info ; 1687 p_pipe_info = p_nfcipinfo->p_init_pipe_info; 1688 1689 if(NULL == p_pipe_info ) 1690 { 1691 status = PHNFCSTVAL(CID_NFC_HCI, 1692 NFCSTATUS_INVALID_HCI_INFORMATION); 1693 } 1694 else 1695 { 1696 pipeid = p_pipe_info->pipe.pipe_id ; 1697 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_DID; 1698 1699 p_pipe_info->param_info = &did; 1700 p_pipe_info->param_length = sizeof(uint8_t); 1701 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1702 pipeid, (uint8_t)ANY_SET_PARAMETER); 1703 } 1704 } 1705 return status; 1706 } 1707 1708 NFCSTATUS 1709 phHciNfc_NfcIP_SetOptions( 1710 phHciNfc_sContext_t *psHciContext, 1711 void *pHwRef, 1712 phHciNfc_eNfcIPType_t nfciptype, 1713 uint8_t nfcip_options 1714 ) 1715 { 1716 NFCSTATUS status = NFCSTATUS_SUCCESS; 1717 1718 if( (NULL == psHciContext) || (NULL == pHwRef)) 1719 { 1720 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1721 } 1722 else if (NFCIP_INVALID == nfciptype) 1723 { 1724 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 1725 } 1726 else if(NULL == psHciContext->p_nfcip_info) 1727 { 1728 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 1729 } 1730 else 1731 { 1732 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 1733 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 1734 uint8_t pipeid = 0; 1735 1736 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 1737 psHciContext->p_nfcip_info ; 1738 p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)? 1739 p_nfcipinfo->p_init_pipe_info: 1740 p_nfcipinfo->p_tgt_pipe_info); 1741 pipeid = p_pipe_info->pipe.pipe_id ; 1742 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_OPTIONS; 1743 1744 p_pipe_info->param_info = &nfcip_options; 1745 p_pipe_info->param_length = sizeof(uint8_t); 1746 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1747 pipeid, (uint8_t)ANY_SET_PARAMETER); 1748 } 1749 return status; 1750 } 1751 1752 NFCSTATUS 1753 phHciNfc_NfcIP_SetATRInfo( 1754 phHciNfc_sContext_t *psHciContext, 1755 void *pHwRef, 1756 phHciNfc_eNfcIPType_t nfciptype, 1757 phHal_sNfcIPCfg_t *atr_info 1758 ) 1759 { 1760 NFCSTATUS status = NFCSTATUS_SUCCESS; 1761 1762 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == atr_info) || 1763 (atr_info->generalBytesLength == 0) || 1764 (atr_info->generalBytesLength > NFCIP_ATR_MAX_LENGTH)) 1765 { 1766 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1767 } 1768 else if (NFCIP_INVALID == nfciptype) 1769 { 1770 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 1771 } 1772 else if(NULL == psHciContext->p_nfcip_info) 1773 { 1774 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 1775 } 1776 else 1777 { 1778 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 1779 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 1780 uint8_t pipeid = 0; 1781 1782 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 1783 psHciContext->p_nfcip_info ; 1784 p_pipe_info = ((NFCIP_INITIATOR == nfciptype)? 1785 p_nfcipinfo->p_init_pipe_info: 1786 p_nfcipinfo->p_tgt_pipe_info); 1787 1788 if(NULL == p_pipe_info ) 1789 { 1790 status = PHNFCSTVAL(CID_NFC_HCI, 1791 NFCSTATUS_INVALID_HCI_INFORMATION); 1792 } 1793 else 1794 { 1795 pipeid = p_pipe_info->pipe.pipe_id ; 1796 p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR == nfciptype)? 1797 NXP_NFCIP_ATR_REQ : 1798 NXP_NFCIP_ATR_RES); 1799 1800 p_pipe_info->param_info = atr_info->generalBytes; 1801 p_pipe_info->param_length = (uint8_t) 1802 atr_info->generalBytesLength; 1803 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1804 pipeid, (uint8_t)ANY_SET_PARAMETER); 1805 } 1806 } 1807 return status; 1808 } 1809 1810 NFCSTATUS 1811 phHciNfc_NfcIP_SetPSL1( 1812 phHciNfc_sContext_t *psHciContext, 1813 void *pHwRef, 1814 uint8_t psl1 1815 ) 1816 { 1817 NFCSTATUS status = NFCSTATUS_SUCCESS; 1818 1819 if( (NULL == psHciContext) || (NULL == pHwRef)) 1820 { 1821 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1822 } 1823 else if(NULL == psHciContext->p_nfcip_info) 1824 { 1825 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 1826 } 1827 else 1828 { 1829 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 1830 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 1831 uint8_t pipeid = 0; 1832 1833 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 1834 psHciContext->p_nfcip_info ; 1835 p_pipe_info = p_nfcipinfo->p_init_pipe_info; 1836 1837 if(NULL == p_pipe_info ) 1838 { 1839 status = PHNFCSTVAL(CID_NFC_HCI, 1840 NFCSTATUS_INVALID_HCI_INFORMATION); 1841 } 1842 else 1843 { 1844 pipeid = p_pipe_info->pipe.pipe_id ; 1845 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PSL1; 1846 1847 p_pipe_info->param_info = &psl1; 1848 p_pipe_info->param_length = sizeof(uint8_t); 1849 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1850 pipeid, (uint8_t)ANY_SET_PARAMETER); 1851 } 1852 } 1853 return status; 1854 } 1855 1856 NFCSTATUS 1857 phHciNfc_NfcIP_SetPSL2( 1858 phHciNfc_sContext_t *psHciContext, 1859 void *pHwRef, 1860 uint8_t psl2 1861 ) 1862 { 1863 NFCSTATUS status = NFCSTATUS_SUCCESS; 1864 1865 if( (NULL == psHciContext) || (NULL == pHwRef)) 1866 { 1867 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1868 } 1869 else if(NULL == psHciContext->p_nfcip_info) 1870 { 1871 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 1872 } 1873 else 1874 { 1875 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 1876 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 1877 uint8_t pipeid = 0; 1878 1879 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 1880 psHciContext->p_nfcip_info ; 1881 p_pipe_info = p_nfcipinfo->p_init_pipe_info; 1882 1883 if(NULL == p_pipe_info ) 1884 { 1885 status = PHNFCSTVAL(CID_NFC_HCI, 1886 NFCSTATUS_INVALID_HCI_INFORMATION); 1887 } 1888 else 1889 { 1890 pipeid = p_pipe_info->pipe.pipe_id ; 1891 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PSL2; 1892 1893 p_pipe_info->param_info = &psl2; 1894 p_pipe_info->param_length = sizeof(uint8_t); 1895 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1896 pipeid, (uint8_t)ANY_SET_PARAMETER); 1897 } 1898 } 1899 return status; 1900 } 1901 1902 NFCSTATUS 1903 phHciNfc_NfcIP_GetStatus( 1904 phHciNfc_sContext_t *psHciContext, 1905 void *pHwRef, 1906 phHciNfc_eNfcIPType_t nfciptype 1907 ) 1908 { 1909 NFCSTATUS status = NFCSTATUS_SUCCESS; 1910 1911 if( (NULL == psHciContext) || (NULL == pHwRef)) 1912 { 1913 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1914 } 1915 else if (NFCIP_INVALID == nfciptype) 1916 { 1917 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 1918 } 1919 else if(NULL == psHciContext->p_nfcip_info) 1920 { 1921 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 1922 } 1923 else 1924 { 1925 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 1926 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 1927 uint8_t pipeid = 0; 1928 1929 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 1930 psHciContext->p_nfcip_info ; 1931 p_pipe_info = ((NFCIP_INITIATOR == nfciptype)? 1932 p_nfcipinfo->p_init_pipe_info : 1933 p_nfcipinfo->p_tgt_pipe_info); 1934 if(NULL == p_pipe_info ) 1935 { 1936 status = PHNFCSTVAL(CID_NFC_HCI, 1937 NFCSTATUS_INVALID_HCI_INFORMATION); 1938 } 1939 else 1940 { 1941 pipeid = p_pipe_info->pipe.pipe_id ; 1942 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_STATUS; 1943 1944 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1945 pipeid, (uint8_t)ANY_GET_PARAMETER); 1946 } 1947 } 1948 return status; 1949 } 1950 1951 NFCSTATUS 1952 phHciNfc_NfcIP_GetParam( 1953 phHciNfc_sContext_t *psHciContext, 1954 void *pHwRef, 1955 phHciNfc_eNfcIPType_t nfciptype 1956 ) 1957 { 1958 NFCSTATUS status = NFCSTATUS_SUCCESS; 1959 1960 if( (NULL == psHciContext) || (NULL == pHwRef)) 1961 { 1962 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1963 } 1964 else if (NFCIP_INVALID == nfciptype) 1965 { 1966 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 1967 } 1968 else if(NULL == psHciContext->p_nfcip_info) 1969 { 1970 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 1971 } 1972 else 1973 { 1974 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 1975 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 1976 uint8_t pipeid = 0; 1977 1978 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 1979 psHciContext->p_nfcip_info ; 1980 p_pipe_info = ((NFCIP_INITIATOR == nfciptype)? 1981 p_nfcipinfo->p_init_pipe_info : 1982 p_nfcipinfo->p_tgt_pipe_info); 1983 if(NULL == p_pipe_info ) 1984 { 1985 status = PHNFCSTVAL(CID_NFC_HCI, 1986 NFCSTATUS_INVALID_HCI_INFORMATION); 1987 } 1988 else 1989 { 1990 pipeid = p_pipe_info->pipe.pipe_id ; 1991 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PARAM; 1992 1993 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 1994 pipeid, (uint8_t)ANY_GET_PARAMETER); 1995 } 1996 } 1997 return status; 1998 } 1999 2000 NFCSTATUS 2001 phHciNfc_Initiator_Cont_Activate ( 2002 phHciNfc_sContext_t *psHciContext, 2003 void *pHwRef 2004 ) 2005 { 2006 NFCSTATUS status = NFCSTATUS_SUCCESS; 2007 2008 if( (NULL == psHciContext) || (NULL == pHwRef) ) 2009 { 2010 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 2011 } 2012 else if(NULL == psHciContext->p_nfcip_info) 2013 { 2014 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 2015 } 2016 else 2017 { 2018 phHciNfc_NfcIP_Info_t *p_nfcipinfo = NULL; 2019 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 2020 2021 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 2022 psHciContext->p_nfcip_info ; 2023 p_nfcipinfo->nfcip_type = NFCIP_INITIATOR; 2024 psHciContext->host_rf_type = phHal_eNfcIP1_Initiator; 2025 p_pipe_info = p_nfcipinfo->p_init_pipe_info; 2026 if(NULL == p_pipe_info ) 2027 { 2028 status = PHNFCSTVAL(CID_NFC_HCI, 2029 NFCSTATUS_INVALID_HCI_INFORMATION); 2030 } 2031 else 2032 { 2033 phHciNfc_HCP_Packet_t *hcp_packet = NULL; 2034 uint16_t length = HCP_HEADER_LEN; 2035 uint8_t pipeid = 0; 2036 2037 pipeid = p_pipe_info->pipe.pipe_id; 2038 psHciContext->tx_total = 0 ; 2039 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer; 2040 /* Construct the HCP Frame */ 2041 phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT, 2042 (uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_COMMAND, 2043 (uint8_t)NXP_NFCI_CONTINUE_ACTIVATION); 2044 2045 p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_COMMAND; 2046 p_pipe_info->prev_msg = (uint8_t)NXP_NFCI_CONTINUE_ACTIVATION; 2047 psHciContext->tx_total = length; 2048 psHciContext->response_pending = (uint8_t)TRUE; 2049 2050 /* Send the Constructed HCP packet to the lower layer */ 2051 status = phHciNfc_Send_HCP( psHciContext, pHwRef); 2052 p_pipe_info->prev_status = status; 2053 } 2054 } 2055 return status; 2056 } 2057 2058 2059 NFCSTATUS 2060 phHciNfc_NfcIP_GetATRInfo ( 2061 phHciNfc_sContext_t *psHciContext, 2062 void *pHwRef, 2063 phHciNfc_eNfcIPType_t nfciptype 2064 ) 2065 { 2066 NFCSTATUS status = NFCSTATUS_SUCCESS; 2067 2068 if( (NULL == psHciContext) 2069 || (NULL == pHwRef)) 2070 { 2071 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 2072 } 2073 else if (NFCIP_INVALID == nfciptype) 2074 { 2075 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 2076 } 2077 else if(NULL == psHciContext->p_nfcip_info) 2078 { 2079 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 2080 } 2081 else 2082 { 2083 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL; 2084 phHciNfc_Pipe_Info_t *p_pipe_info=NULL; 2085 uint8_t pipeid = 0; 2086 2087 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 2088 psHciContext->p_nfcip_info ; 2089 2090 p_pipe_info = ((NFCIP_INITIATOR == nfciptype)? 2091 p_nfcipinfo->p_init_pipe_info : 2092 p_nfcipinfo->p_tgt_pipe_info); 2093 2094 if(NULL == p_pipe_info ) 2095 { 2096 status = PHNFCSTVAL(CID_NFC_HCI, 2097 NFCSTATUS_INVALID_HCI_INFORMATION); 2098 } 2099 else 2100 { 2101 p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR == nfciptype)? 2102 NXP_NFCIP_ATR_RES : 2103 NXP_NFCIP_ATR_REQ); 2104 pipeid = p_pipe_info->pipe.pipe_id ; 2105 /* Fill the data buffer and send the command to the 2106 device */ 2107 status = 2108 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 2109 pipeid, (uint8_t)ANY_GET_PARAMETER); 2110 } 2111 } 2112 return status; 2113 } 2114 2115 NFCSTATUS 2116 phHciNfc_NfcIP_SetMergeSak( 2117 phHciNfc_sContext_t *psHciContext, 2118 void *pHwRef, 2119 uint8_t sak_value 2120 ) 2121 { 2122 NFCSTATUS status = NFCSTATUS_SUCCESS; 2123 2124 if( (NULL == psHciContext) || (NULL == pHwRef) || 2125 (sak_value > (uint8_t)TRUE)) 2126 { 2127 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 2128 } 2129 else if(NULL == psHciContext->p_nfcip_info) 2130 { 2131 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 2132 } 2133 else 2134 { 2135 phHciNfc_NfcIP_Info_t *ps_nfcipinfo=NULL; 2136 phHciNfc_Pipe_Info_t *ps_pipe_info=NULL; 2137 uint8_t pipeid = 0; 2138 2139 ps_nfcipinfo = (phHciNfc_NfcIP_Info_t *) 2140 psHciContext->p_nfcip_info ; 2141 ps_pipe_info = ps_nfcipinfo->p_tgt_pipe_info; 2142 2143 if(NULL == ps_pipe_info ) 2144 { 2145 status = PHNFCSTVAL(CID_NFC_HCI, 2146 NFCSTATUS_INVALID_HCI_INFORMATION); 2147 } 2148 else 2149 { 2150 pipeid = ps_pipe_info->pipe.pipe_id ; 2151 ps_pipe_info->reg_index = (uint8_t)NXP_NFCIP_MERGE; 2152 2153 ps_pipe_info->param_info = &sak_value; 2154 ps_pipe_info->param_length = sizeof(uint8_t); 2155 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef, 2156 pipeid, (uint8_t)ANY_SET_PARAMETER); 2157 } 2158 } 2159 return status; 2160 } 2161 2162 #endif /* #if defined (ENABLE_P2P) */ 2163 2164
