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 * * 22 * \file phHciNfc_DevMgmt.c * 23 * \brief HCI PN544 Device Management Gate Routines. * 24 * * 25 * * 26 * Project: NFC-FRI-1.1 * 27 * * 28 * $Date: Fri Mar 12 10:21:54 2010 $ * 29 * $Author: ing04880 $ * 30 * $Revision: 1.29 $ * 31 * $Aliases: NFC_FRI1.1_WK1007_R33_3,NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $ * 32 * * 33 * =========================================================================== * 34 */ 35 36 /* 37 ***************************** Header File Inclusion **************************** 38 */ 39 #include <phNfcConfig.h> 40 #include <phNfcCompId.h> 41 #include <phHciNfc_Pipe.h> 42 #include <phHciNfc_DevMgmt.h> 43 #include <phHciNfc_Emulation.h> 44 #include <phOsalNfc.h> 45 46 /* 47 ****************************** Macro Definitions ******************************* 48 */ 49 50 /* Commands for System Management module */ 51 #define NXP_RF_CHECK_SETTINGS 0x10U 52 #define NXP_RF_UPDATE_SETTINGS 0x11U 53 54 /* Self Test Commands */ 55 #define NXP_SELF_TEST_ANTENNA 0x20U 56 #define NXP_SELF_TEST_SWP 0x21U 57 #define NXP_SELF_TEST_NFCWI 0x22U 58 #define NXP_SELF_TEST_PRBS 0x25U 59 60 /* System Management propreitary control */ 61 #define NXP_DBG_READ 0x3EU 62 #define NXP_DBG_WRITE 0x3FU 63 64 /* System Management Events */ 65 #define NXP_EVT_SET_AUTONOMOUS 0x01U 66 #define NXP_EVT_CLF_WAKEUP 0x02U 67 68 /* System Management Information Events */ 69 #define NXP_EVT_INFO_TXLDO_OVERCUR 0x10U 70 #define NXP_EVT_INFO_PMUVCC 0x11U 71 #define NXP_EVT_INFO_EXT_RF_FIELD 0x12U 72 #define NXP_EVT_INFO_MEM_VIOLATION 0x13U 73 #define NXP_EVT_INFO_TEMP_OVERHEAT 0x14U 74 #define NXP_EVT_INFO_LLC_ERROR 0x15U 75 76 #define NFC_DEV_TXLDO_MASK 0x03U 77 78 79 /* 80 *************************** Structure and Enumeration *************************** 81 */ 82 83 84 /** \defgroup grp_hci_nfc HCI PN544 Device Management Component 85 * 86 * 87 */ 88 89 typedef enum phHciNfc_DevMgmt_Seq{ 90 DEV_MGMT_PIPE_OPEN = 0x00U, 91 DEV_MGMT_SET_PWR_STATUS, 92 DEV_MGMT_SET_INFO_EVT, 93 DEV_MGMT_GET_EEPROM_INFO, 94 DEV_MGMT_GPIO_PDIR, 95 DEV_MGMT_GPIO_PEN, 96 DEV_MGMT_TX_LDO, 97 DEV_MGMT_IFC_TO_RX_H, 98 DEV_MGMT_IFC_TO_RX_L, 99 DEV_MGMT_IFC_TO_TX_H, 100 DEV_MGMT_IFC_TO_TX_L, 101 DEV_MGMT_ANAIRQ_CONF, 102 DEV_MGMT_PMOS_MOD, 103 DEV_MGMT_CLK_REQ, 104 DEV_MGMT_INPUT_CLK, 105 DEV_MGMT_UICC_PWR_REQUEST, 106 DEV_MGMT_ACTIVE_GUARD_TO, 107 DEV_MGMT_MAX_ACT_TO_LOW, 108 DEV_MGMT_MAX_ACT_TO_HIGH, 109 DEV_MGMT_UICC_CE_A_ACCESS, 110 DEV_MGMT_UICC_CE_B_ACCESS, 111 DEV_MGMT_UICC_CE_BP_ACCESS, 112 DEV_MGMT_UICC_CE_F_ACCESS, 113 DEV_MGMT_UICC_RD_A_ACCESS, 114 DEV_MGMT_UICC_RD_B_ACCESS, 115 DEV_MGMT_UICC_BIT_RATE, 116 DEV_MGMT_UICC_RX_ERR_CNT, 117 DEV_MGMT_UICC_TX_ERR_CNT, 118 DEV_MGMT_LLC_GRD_TO_H, 119 DEV_MGMT_LLC_GRD_TO_L, 120 DEV_MGMT_LLC_ACK_TO_H, 121 DEV_MGMT_LLC_ACK_TO_L, 122 DEV_MGMT_FELICA_RC, 123 DEV_MGMT_EVT_AUTONOMOUS, 124 DEV_MGMT_PIPE_CLOSE 125 } phHciNfc_DevMgmt_Seq_t; 126 127 128 typedef struct phHciNfc_DevMgmt_Info{ 129 phHciNfc_DevMgmt_Seq_t current_seq; 130 phHciNfc_DevMgmt_Seq_t next_seq; 131 phHciNfc_Pipe_Info_t *p_pipe_info; 132 uint8_t test_status; 133 uint8_t value; 134 uint8_t rf_status; 135 uint8_t pmuvcc_status; 136 uint8_t overheat_status; 137 uint8_t *p_val; 138 uint8_t eeprom_crc; 139 phNfc_sData_t test_result; 140 141 } phHciNfc_DevMgmt_Info_t; 142 143 144 /* 145 *************************** Static Function Declaration ************************** 146 */ 147 148 static 149 NFCSTATUS 150 phHciNfc_DevMgmt_InfoUpdate( 151 phHciNfc_sContext_t *psHciContext, 152 phHal_sHwReference_t *pHwRef, 153 uint8_t index, 154 uint8_t *reg_value, 155 uint8_t reg_length 156 ); 157 158 static 159 NFCSTATUS 160 phHciNfc_Recv_DevMgmt_Response( 161 void *psHciContext, 162 void *pHwRef, 163 uint8_t *pResponse, 164 #ifdef ONE_BYTE_LEN 165 uint8_t length 166 #else 167 uint16_t length 168 #endif 169 ); 170 171 static 172 NFCSTATUS 173 phHciNfc_Recv_DevMgmt_Event( 174 void *psContext, 175 void *pHwRef, 176 uint8_t *pEvent, 177 #ifdef ONE_BYTE_LEN 178 uint8_t length 179 #else 180 uint16_t length 181 #endif 182 ); 183 184 185 static 186 NFCSTATUS 187 phHciNfc_Send_DevMgmt_Command ( 188 phHciNfc_sContext_t *psHciContext, 189 void *pHwRef, 190 uint8_t pipe_id, 191 uint8_t cmd 192 ); 193 194 static 195 NFCSTATUS 196 phHciNfc_Send_DevMgmt_Event ( 197 phHciNfc_sContext_t *psHciContext, 198 void *pHwRef, 199 uint8_t pipe_id, 200 uint8_t event 201 ); 202 203 /* 204 *************************** Function Definitions *************************** 205 */ 206 207 208 NFCSTATUS 209 phHciNfc_DevMgmt_Init_Resources( 210 phHciNfc_sContext_t *psHciContext 211 ) 212 { 213 NFCSTATUS status = NFCSTATUS_SUCCESS; 214 phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL; 215 216 if( NULL == psHciContext ) 217 { 218 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 219 } 220 else 221 { 222 if(( NULL == psHciContext->p_device_mgmt_info ) && 223 (phHciNfc_Allocate_Resource((void **)(&p_device_mgmt_info), 224 sizeof(phHciNfc_DevMgmt_Info_t))== NFCSTATUS_SUCCESS)) 225 { 226 psHciContext->p_device_mgmt_info = p_device_mgmt_info; 227 p_device_mgmt_info->current_seq = DEV_MGMT_PIPE_OPEN; 228 p_device_mgmt_info->next_seq = DEV_MGMT_PIPE_OPEN; 229 p_device_mgmt_info->p_pipe_info = NULL; 230 } 231 else 232 { 233 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES); 234 } 235 } 236 return status; 237 } 238 239 240 NFCSTATUS 241 phHciNfc_DevMgmt_Get_PipeID( 242 phHciNfc_sContext_t *psHciContext, 243 uint8_t *ppipe_id 244 ) 245 { 246 NFCSTATUS status = NFCSTATUS_SUCCESS; 247 248 if( (NULL != psHciContext) 249 && ( NULL != ppipe_id ) 250 && ( NULL != psHciContext->p_device_mgmt_info ) 251 ) 252 { 253 phHciNfc_Pipe_Info_t *p_pipe_info = NULL; 254 p_pipe_info = ((phHciNfc_DevMgmt_Info_t *) 255 psHciContext->p_device_mgmt_info)->p_pipe_info ; 256 if (NULL != p_pipe_info) 257 { 258 *ppipe_id = p_pipe_info->pipe.pipe_id ; 259 } 260 else 261 { 262 *ppipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID; 263 } 264 265 } 266 else 267 { 268 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 269 } 270 return status; 271 } 272 273 274 NFCSTATUS 275 phHciNfc_DevMgmt_Get_Test_Result( 276 phHciNfc_sContext_t *psHciContext, 277 phNfc_sData_t *p_test_result 278 ) 279 { 280 NFCSTATUS status = NFCSTATUS_SUCCESS; 281 282 if( (NULL != psHciContext) 283 && ( NULL != p_test_result ) 284 && ( NULL != psHciContext->p_device_mgmt_info ) 285 ) 286 { 287 phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL; 288 p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *) 289 psHciContext->p_device_mgmt_info ; 290 p_test_result->buffer = p_device_mgmt_info->test_result.buffer; 291 p_test_result->length = p_device_mgmt_info->test_result.length; 292 293 } 294 else 295 { 296 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 297 } 298 299 return status; 300 } 301 302 303 NFCSTATUS 304 phHciNfc_DevMgmt_Set_Test_Result( 305 phHciNfc_sContext_t *psHciContext, 306 uint8_t test_status 307 ) 308 { 309 NFCSTATUS status = NFCSTATUS_SUCCESS; 310 311 if( (NULL != psHciContext) 312 && ( NULL != psHciContext->p_device_mgmt_info ) 313 ) 314 { 315 phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL; 316 p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *) 317 psHciContext->p_device_mgmt_info ; 318 p_device_mgmt_info->test_status = test_status; 319 320 } 321 else 322 { 323 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 324 } 325 326 return status; 327 } 328 329 330 331 NFCSTATUS 332 phHciNfc_DevMgmt_Update_PipeInfo( 333 phHciNfc_sContext_t *psHciContext, 334 uint8_t pipeID, 335 phHciNfc_Pipe_Info_t *pPipeInfo 336 ) 337 { 338 NFCSTATUS status = NFCSTATUS_SUCCESS; 339 340 if( NULL == psHciContext ) 341 { 342 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 343 } 344 else if(NULL == psHciContext->p_device_mgmt_info) 345 { 346 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 347 } 348 else 349 { 350 phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL; 351 p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *) 352 psHciContext->p_device_mgmt_info ; 353 /* Update the pipe_info of the Device Management Gate obtained 354 * from HCI Response */ 355 p_device_mgmt_info->p_pipe_info = pPipeInfo; 356 if (( NULL != pPipeInfo) 357 && ((uint8_t)HCI_UNKNOWN_PIPE_ID != pipeID) 358 ) 359 { 360 /* Update the Response Receive routine of the Device 361 * Managment Gate */ 362 pPipeInfo->recv_resp = &phHciNfc_Recv_DevMgmt_Response; 363 pPipeInfo->recv_event = &phHciNfc_Recv_DevMgmt_Event; 364 } 365 } 366 367 return status; 368 } 369 370 371 NFCSTATUS 372 phHciNfc_DevMgmt_Configure ( 373 phHciNfc_sContext_t *psHciContext, 374 void *pHwRef, 375 uint16_t address, 376 uint8_t value 377 ) 378 { 379 NFCSTATUS status = NFCSTATUS_SUCCESS; 380 phHciNfc_Pipe_Info_t *p_pipe_info = NULL; 381 uint8_t pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID; 382 uint8_t i=0; 383 uint8_t params[5]; 384 385 if( (NULL == psHciContext) || (NULL == pHwRef) ) 386 { 387 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 388 } 389 else if( NULL == psHciContext->p_device_mgmt_info ) 390 { 391 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 392 } 393 else 394 { 395 p_pipe_info = ((phHciNfc_DevMgmt_Info_t *) 396 psHciContext->p_device_mgmt_info)->p_pipe_info ; 397 398 if(NULL == p_pipe_info ) 399 { 400 status = PHNFCSTVAL(CID_NFC_HCI, 401 NFCSTATUS_INVALID_HCI_SEQUENCE); 402 } 403 else 404 { 405 pipe_id = p_pipe_info->pipe.pipe_id ; 406 params[i++] = 0x00; 407 params[i++] = (uint8_t)(address >> BYTE_SIZE); 408 params[i++] = (uint8_t)address; 409 params[i++] = value; 410 p_pipe_info->param_info = ¶ms; 411 p_pipe_info->param_length = i ; 412 status = phHciNfc_Send_DevMgmt_Command( psHciContext, pHwRef, 413 pipe_id, (uint8_t)NXP_DBG_WRITE ); 414 } 415 } 416 return status; 417 } 418 419 420 NFCSTATUS 421 phHciNfc_DevMgmt_Get_Info ( 422 phHciNfc_sContext_t *psHciContext, 423 void *pHwRef, 424 uint16_t address, 425 uint8_t *p_val 426 ) 427 { 428 NFCSTATUS status = NFCSTATUS_SUCCESS; 429 phHciNfc_Pipe_Info_t *p_pipe_info = NULL; 430 uint8_t pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID; 431 uint8_t i=0; 432 uint8_t params[5]; 433 434 if( (NULL == psHciContext) || (NULL == pHwRef) ) 435 { 436 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 437 } 438 else if( NULL == psHciContext->p_device_mgmt_info ) 439 { 440 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 441 } 442 else 443 { 444 p_pipe_info = ((phHciNfc_DevMgmt_Info_t *) 445 psHciContext->p_device_mgmt_info)->p_pipe_info ; 446 447 if(NULL == p_pipe_info ) 448 { 449 status = PHNFCSTVAL(CID_NFC_HCI, 450 NFCSTATUS_INVALID_HCI_SEQUENCE); 451 } 452 else 453 { 454 ((phHciNfc_DevMgmt_Info_t *) 455 psHciContext->p_device_mgmt_info)->p_val = p_val; 456 pipe_id = p_pipe_info->pipe.pipe_id ; 457 params[i++] = 0x00; 458 params[i++] = (uint8_t)(address >> BYTE_SIZE); 459 params[i++] = (uint8_t) address; 460 p_pipe_info->param_info = ¶ms; 461 p_pipe_info->param_length = i ; 462 status = phHciNfc_Send_DevMgmt_Command( psHciContext, pHwRef, 463 pipe_id, (uint8_t)NXP_DBG_READ ); 464 } 465 } 466 return status; 467 468 } 469 470 /*! 471 * \brief Initialisation of PN544 Device Managment Gate. 472 * 473 * This function initialses the PN544 Device Management gate and 474 * populates the PN544 Device Management Information Structure 475 * 476 */ 477 478 NFCSTATUS 479 phHciNfc_DevMgmt_Initialise( 480 phHciNfc_sContext_t *psHciContext, 481 void *pHwRef 482 ) 483 { 484 NFCSTATUS status = NFCSTATUS_SUCCESS; 485 phHciNfc_Pipe_Info_t *p_pipe_info = NULL; 486 phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL; 487 static uint8_t config = 0x10; 488 489 if( ( NULL == psHciContext ) 490 || (NULL == pHwRef ) 491 ) 492 { 493 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 494 } 495 else if (NULL == psHciContext->p_device_mgmt_info) 496 { 497 status = PHNFCSTVAL(CID_NFC_HCI, 498 NFCSTATUS_INVALID_HCI_INFORMATION); 499 }/* End of the PN544 Device Info Memory Check */ 500 else 501 { 502 p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *) 503 psHciContext->p_device_mgmt_info ; 504 p_pipe_info = p_device_mgmt_info->p_pipe_info; 505 506 if (NULL == p_pipe_info) 507 { 508 status = PHNFCSTVAL(CID_NFC_HCI, 509 NFCSTATUS_INVALID_HCI_SEQUENCE); 510 } 511 else 512 { 513 switch(p_device_mgmt_info->current_seq ) 514 { 515 /* PN544 Device Mgmt pipe open sequence */ 516 case DEV_MGMT_PIPE_OPEN: 517 { 518 status = phHciNfc_Open_Pipe( psHciContext, 519 pHwRef, p_pipe_info ); 520 if(status == NFCSTATUS_SUCCESS) 521 { 522 p_device_mgmt_info->next_seq = 523 DEV_MGMT_FELICA_RC; 524 status = NFCSTATUS_PENDING; 525 } 526 break; 527 } 528 case DEV_MGMT_GET_EEPROM_INFO: 529 { 530 p_pipe_info->reg_index = DEVICE_INFO_EEPROM_INDEX; 531 status = phHciNfc_Send_Generic_Cmd( psHciContext, 532 pHwRef, (uint8_t)p_pipe_info->pipe.pipe_id, 533 (uint8_t)ANY_GET_PARAMETER); 534 if(NFCSTATUS_PENDING == status ) 535 { 536 #if ( NXP_NFC_IFC_TIMEOUT & 0x01 ) 537 p_device_mgmt_info->next_seq = 538 DEV_MGMT_IFC_TO_TX_H; 539 #else 540 p_device_mgmt_info->next_seq = 541 DEV_MGMT_TX_LDO; 542 #endif /* #if ( NXP_NFC_IFC_TIMEOUT & 0x01 ) */ 543 } 544 break; 545 } 546 case DEV_MGMT_GPIO_PDIR: 547 { 548 config = 0x00; 549 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 550 NFC_ADDRESS_GPIO_PDIR , config ); 551 if(NFCSTATUS_PENDING == status ) 552 { 553 p_device_mgmt_info->next_seq = 554 DEV_MGMT_GPIO_PEN; 555 } 556 break; 557 } 558 case DEV_MGMT_GPIO_PEN: 559 { 560 config = NXP_NFC_GPIO_MASK(NXP_DOWNLOAD_GPIO)| 0x03 ; 561 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 562 NFC_ADDRESS_GPIO_PEN , config ); 563 if(NFCSTATUS_PENDING == status ) 564 { 565 #if ( NXP_NFC_IFC_TIMEOUT & 0x01 ) 566 p_device_mgmt_info->next_seq = 567 DEV_MGMT_IFC_TO_TX_H; 568 #else 569 p_device_mgmt_info->next_seq = 570 DEV_MGMT_TX_LDO; 571 #endif /* #if ( NXP_NFC_IFC_TIMEOUT & 0x01 ) */ 572 } 573 break; 574 } 575 case DEV_MGMT_FELICA_RC: 576 { 577 config = 0x00; 578 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 579 NFC_FELICA_RC_ADDR , config ); 580 if(NFCSTATUS_PENDING == status ) 581 { 582 583 if ((HCI_SELF_TEST == psHciContext->init_mode ) 584 || (HCI_NFC_DEVICE_TEST == psHciContext->init_mode )) 585 { 586 p_device_mgmt_info->next_seq = 587 DEV_MGMT_GPIO_PDIR; 588 } 589 else 590 { 591 p_device_mgmt_info->next_seq = 592 DEV_MGMT_GET_EEPROM_INFO; 593 } 594 } 595 break; 596 } 597 598 #if ( NXP_NFC_IFC_TIMEOUT & 0x01 ) 599 600 case DEV_MGMT_IFC_TO_TX_H: 601 { 602 config = (uint8_t) 603 ( NXP_NFC_IFC_CONFIG_DEFAULT >> BYTE_SIZE ) /* 0x03 */; 604 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 605 NFC_ADDRESS_IFC_TO_TX_H , config ); 606 if(NFCSTATUS_PENDING == status ) 607 { 608 p_device_mgmt_info->next_seq = 609 DEV_MGMT_IFC_TO_TX_L; 610 } 611 break; 612 } 613 case DEV_MGMT_IFC_TO_TX_L: 614 { 615 config = (uint8_t) 616 ( NXP_NFC_IFC_CONFIG_DEFAULT & BYTE_MASK ) /* 0xE8 */; 617 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 618 NFC_ADDRESS_IFC_TO_TX_L , config ); 619 if(NFCSTATUS_PENDING == status ) 620 { 621 #if ( NXP_NFC_IFC_TIMEOUT & 0x02 ) 622 p_device_mgmt_info->next_seq = 623 DEV_MGMT_IFC_TO_RX_H; 624 #else 625 p_device_mgmt_info->next_seq = 626 DEV_MGMT_TX_LDO; 627 #endif /* #if ( NXP_NFC_IFC_TIMEOUT & 0x02 ) */ 628 } 629 break; 630 } 631 case DEV_MGMT_IFC_TO_RX_H: 632 { 633 config = 0x10; 634 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 635 NFC_ADDRESS_IFC_TO_RX_H , config ); 636 if(NFCSTATUS_PENDING == status ) 637 { 638 p_device_mgmt_info->next_seq = 639 DEV_MGMT_IFC_TO_RX_L; 640 } 641 break; 642 } 643 case DEV_MGMT_IFC_TO_RX_L: 644 { 645 config = 0x1E; 646 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 647 NFC_ADDRESS_IFC_TO_RX_L , config ); 648 if(NFCSTATUS_PENDING == status ) 649 { 650 p_device_mgmt_info->next_seq = 651 DEV_MGMT_TX_LDO; 652 } 653 break; 654 } 655 656 #endif /* #if ( NXP_NFC_IFC_TIMEOUT & 0x01 ) */ 657 case DEV_MGMT_TX_LDO: 658 { 659 #if ( NXP_HAL_VERIFY_EEPROM_CRC & 0x01U ) 660 if (0 != p_device_mgmt_info->eeprom_crc) 661 { 662 status = NFCSTATUS_FAILED; 663 } 664 else 665 #endif 666 { 667 config = (NFC_DEV_HWCONF_DEFAULT | 668 (NXP_DEFAULT_TX_LDO & NFC_DEV_TXLDO_MASK)); 669 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 670 NFC_ADDRESS_HW_CONF , config ); 671 if(NFCSTATUS_PENDING == status ) 672 { 673 #if ( SW_TYPE_RF_TUNING_BF & 0x01) 674 p_device_mgmt_info->next_seq = DEV_MGMT_ANAIRQ_CONF; 675 #else 676 p_device_mgmt_info->next_seq = DEV_MGMT_CLK_REQ; 677 #endif 678 /* status = NFCSTATUS_SUCCESS; */ 679 } 680 } 681 break; 682 } 683 #if ( SW_TYPE_RF_TUNING_BF & 0x01) 684 /* The Analogue IRQ Configuartion */ 685 case DEV_MGMT_ANAIRQ_CONF: 686 { 687 config = 0x04; 688 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 689 NFC_ADDRESS_ANAIRQ_CONF , config ); 690 if(NFCSTATUS_PENDING == status ) 691 { 692 p_device_mgmt_info->next_seq = 693 DEV_MGMT_PMOS_MOD; 694 /* status = NFCSTATUS_SUCCESS; */ 695 } 696 break; 697 } 698 /* The PMOS Modulation Index */ 699 case DEV_MGMT_PMOS_MOD: 700 { 701 config = NFC_DEV_PMOS_MOD_DEFAULT; 702 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 703 NFC_ADDRESS_PMOS_MOD , config ); 704 if(NFCSTATUS_PENDING == status ) 705 { 706 p_device_mgmt_info->next_seq = 707 DEV_MGMT_CLK_REQ; 708 /* status = NFCSTATUS_SUCCESS; */ 709 } 710 break; 711 } 712 #endif /* #if ( SW_TYPE_RF_TUNING_BF & 0x01) */ 713 case DEV_MGMT_CLK_REQ: 714 { 715 config = ((phHal_sHwConfig_t *) 716 psHciContext->p_config_params)->clk_req ; 717 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 718 NFC_ADDRESS_CLK_REQ , config ); 719 if(NFCSTATUS_PENDING == status ) 720 { 721 p_device_mgmt_info->next_seq = 722 DEV_MGMT_INPUT_CLK; 723 /* status = NFCSTATUS_SUCCESS; */ 724 } 725 break; 726 } 727 case DEV_MGMT_INPUT_CLK: 728 { 729 config = ((phHal_sHwConfig_t *) 730 psHciContext->p_config_params)->input_clk; 731 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 732 NFC_ADDRESS_CLK_INPUT , config ); 733 if(NFCSTATUS_PENDING == status ) 734 { 735 p_device_mgmt_info->next_seq = 736 DEV_MGMT_UICC_PWR_REQUEST; 737 } 738 break; 739 } 740 case DEV_MGMT_UICC_PWR_REQUEST: 741 { 742 config = NXP_UICC_PWR_REQUEST; 743 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 744 NFC_ADDRESS_SWP_PWR_REQ , config ); 745 if(NFCSTATUS_PENDING == status ) 746 { 747 p_device_mgmt_info->next_seq = 748 DEV_MGMT_UICC_RD_A_ACCESS; 749 } 750 break; 751 } 752 case DEV_MGMT_UICC_RD_A_ACCESS: 753 { 754 #if ( NXP_UICC_RD_RIGHTS & 0x01 ) 755 config = (uint8_t) phHciNfc_RFReaderAGate; 756 #else 757 config = 0xFFU; 758 #endif /* #if ( NXP_UICC_RD_RIGHTS & 0x01 ) */ 759 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 760 NFC_ADDRESS_UICC_RD_A_ACCESS , config ); 761 if(NFCSTATUS_PENDING == status ) 762 { 763 p_device_mgmt_info->next_seq = 764 DEV_MGMT_UICC_RD_B_ACCESS; 765 } 766 break; 767 } 768 case DEV_MGMT_UICC_RD_B_ACCESS: 769 { 770 #if ( NXP_UICC_RD_RIGHTS & 0x02 ) 771 config = (uint8_t) phHciNfc_RFReaderBGate; 772 #else 773 config = 0xFFU; 774 #endif /* #if ( NXP_UICC_RD_RIGHTS & 0x02 ) */ 775 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 776 NFC_ADDRESS_UICC_RD_B_ACCESS , config ); 777 if(NFCSTATUS_PENDING == status ) 778 { 779 p_device_mgmt_info->next_seq = 780 DEV_MGMT_UICC_CE_A_ACCESS; 781 } 782 break; 783 } 784 case DEV_MGMT_UICC_CE_A_ACCESS: 785 { 786 #if defined(HOST_EMULATION) || ( NXP_UICC_CE_RIGHTS & 0x01 ) 787 config = (uint8_t) phHciNfc_CETypeAGate; 788 #else 789 config = 0xFFU; 790 #endif /* #if ( NXP_UICC_CE_RIGHTS & 0x01 ) */ 791 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 792 NFC_ADDRESS_UICC_CE_A_ACCESS , config ); 793 if(NFCSTATUS_PENDING == status ) 794 { 795 p_device_mgmt_info->next_seq = 796 DEV_MGMT_UICC_CE_B_ACCESS; 797 } 798 break; 799 } 800 case DEV_MGMT_UICC_CE_B_ACCESS: 801 { 802 #if defined(HOST_EMULATION) || ( NXP_UICC_CE_RIGHTS & 0x02 ) 803 config = (uint8_t) phHciNfc_CETypeBGate; 804 #else 805 config = 0xFFU; 806 #endif /* #if ( NXP_UICC_CE_RIGHTS & 0x02 ) */ 807 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 808 NFC_ADDRESS_UICC_CE_B_ACCESS , config ); 809 if(NFCSTATUS_PENDING == status ) 810 { 811 p_device_mgmt_info->next_seq = 812 DEV_MGMT_UICC_CE_BP_ACCESS; 813 } 814 break; 815 } 816 case DEV_MGMT_UICC_CE_BP_ACCESS: 817 { 818 #if defined(HOST_EMULATION) || ( NXP_UICC_CE_RIGHTS & 0x04 ) 819 config = (uint8_t) phHciNfc_CETypeBPrimeGate; 820 #else 821 config = 0xFFU; 822 #endif /* #if ( NXP_UICC_CE_RIGHTS & 0x04 ) */ 823 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 824 NFC_ADDRESS_UICC_CE_BP_ACCESS , config ); 825 if(NFCSTATUS_PENDING == status ) 826 { 827 p_device_mgmt_info->next_seq = 828 DEV_MGMT_UICC_CE_F_ACCESS; 829 } 830 break; 831 } 832 case DEV_MGMT_UICC_CE_F_ACCESS: 833 { 834 #if defined(HOST_EMULATION) || ( NXP_UICC_CE_RIGHTS & 0x08 ) 835 config = (uint8_t) phHciNfc_CETypeFGate; 836 #else 837 config = 0xFFU; 838 #endif /* #if ( NXP_UICC_CE_RIGHTS & 0x08 ) */ 839 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 840 NFC_ADDRESS_UICC_CE_F_ACCESS , config ); 841 if(NFCSTATUS_PENDING == status ) 842 { 843 p_device_mgmt_info->next_seq = 844 DEV_MGMT_UICC_BIT_RATE; 845 } 846 break; 847 } 848 case DEV_MGMT_UICC_BIT_RATE: 849 { 850 config = NXP_UICC_BIT_RATE; 851 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 852 NFC_ADDRESS_SWP_BITRATE , config ); 853 if(NFCSTATUS_PENDING == status ) 854 { 855 #if defined (CFG_PWR_STATUS) 856 p_device_mgmt_info->next_seq = 857 DEV_MGMT_SET_PWR_STATUS; 858 #else 859 p_device_mgmt_info->next_seq = 860 DEV_MGMT_SET_INFO_EVT; 861 #endif 862 } 863 break; 864 } 865 #ifdef CFG_PWR_STATUS 866 case DEV_MGMT_SET_PWR_STATUS: 867 { 868 config = NXP_SYSTEM_PWR_STATUS; 869 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 870 NFC_ADDRESS_PWR_STATUS , config ); 871 if(NFCSTATUS_PENDING == status ) 872 { 873 p_device_mgmt_info->next_seq = 874 DEV_MGMT_SET_INFO_EVT; 875 } 876 break; 877 } 878 #endif 879 case DEV_MGMT_SET_INFO_EVT: 880 { 881 config = NXP_SYSTEM_EVT_INFO; 882 status = phHciNfc_Set_Param(psHciContext, pHwRef, 883 p_pipe_info, DEVICE_INFO_EVT_INDEX, 884 (uint8_t *)&config, sizeof(config) ); 885 if(NFCSTATUS_PENDING == status ) 886 { 887 #if ( HOST_LINK_TIMEOUT & 0x01 ) 888 p_device_mgmt_info->next_seq = 889 DEV_MGMT_LLC_GRD_TO_H; 890 #else 891 p_device_mgmt_info->next_seq = 892 DEV_MGMT_EVT_AUTONOMOUS; 893 status = NFCSTATUS_SUCCESS; 894 #endif /* #if ( HOST_LINK_TIMEOUT & 0x01 ) */ 895 } 896 break; 897 } 898 #if ( HOST_LINK_TIMEOUT & 0x01 ) 899 900 case DEV_MGMT_LLC_GRD_TO_H: 901 { 902 config =(uint8_t) 903 ( NXP_NFC_LINK_GRD_CFG_DEFAULT >> BYTE_SIZE ) /* 0x00 */; 904 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 905 NFC_ADDRESS_LLC_GRD_TO_H , config ); 906 if(NFCSTATUS_PENDING == status ) 907 { 908 p_device_mgmt_info->next_seq = 909 DEV_MGMT_LLC_GRD_TO_L; 910 } 911 break; 912 } 913 case DEV_MGMT_LLC_GRD_TO_L: 914 { 915 config = (uint8_t) 916 ( NXP_NFC_LINK_GRD_CFG_DEFAULT & BYTE_MASK ) /* 0x32 */; 917 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 918 NFC_ADDRESS_LLC_GRD_TO_L , config ); 919 if(NFCSTATUS_PENDING == status ) 920 { 921 #if ( HOST_LINK_TIMEOUT & 0x02 ) 922 p_device_mgmt_info->next_seq = 923 DEV_MGMT_LLC_ACK_TO_H; 924 #else 925 p_device_mgmt_info->next_seq = 926 DEV_MGMT_EVT_AUTONOMOUS; 927 status = NFCSTATUS_SUCCESS; 928 #endif /* #if ( HOST_LINK_TIMEOUT & 0x02 ) */ 929 } 930 break; 931 } 932 case DEV_MGMT_LLC_ACK_TO_H: 933 { 934 config = (uint8_t) 935 ( NXP_NFC_LINK_ACK_CFG_DEFAULT >> BYTE_SIZE )/* 0x00 */; 936 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 937 NFC_ADDRESS_LLC_ACK_TO_H , config ); 938 if(NFCSTATUS_PENDING == status ) 939 { 940 p_device_mgmt_info->next_seq = 941 DEV_MGMT_LLC_ACK_TO_L; 942 } 943 break; 944 } 945 case DEV_MGMT_LLC_ACK_TO_L: 946 { 947 config = (uint8_t) 948 ( NXP_NFC_LINK_ACK_CFG_DEFAULT & BYTE_MASK ) /* 0x00 */;; 949 status = phHciNfc_DevMgmt_Configure( psHciContext, pHwRef, 950 NFC_ADDRESS_LLC_ACK_TO_L , config ); 951 if(NFCSTATUS_PENDING == status ) 952 { 953 p_device_mgmt_info->next_seq = 954 DEV_MGMT_EVT_AUTONOMOUS; 955 status = NFCSTATUS_SUCCESS; 956 } 957 break; 958 } 959 960 #endif /* #if ( HOST_LINK_TIMEOUT & 0x01 ) */ 961 default: 962 { 963 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE); 964 break; 965 } 966 967 }/* End of the Sequence Switch */ 968 } 969 970 } /* End of Null Context Check */ 971 972 return status; 973 } 974 975 /*! 976 * \brief Releases the resources allocated the PN544 Device Management. 977 * 978 * This function Releases the resources allocated the PN544 Device Management 979 * and resets the hardware to the reset state. 980 */ 981 982 NFCSTATUS 983 phHciNfc_DevMgmt_Release( 984 phHciNfc_sContext_t *psHciContext, 985 void *pHwRef 986 ) 987 { 988 NFCSTATUS status = NFCSTATUS_SUCCESS; 989 phHciNfc_Pipe_Info_t *p_pipe_info = NULL; 990 phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL; 991 992 if( (NULL == psHciContext) || (NULL == pHwRef) ) 993 { 994 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 995 } 996 else 997 { 998 if( NULL != psHciContext->p_device_mgmt_info ) 999 { 1000 p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *) 1001 psHciContext->p_device_mgmt_info ; 1002 switch(p_device_mgmt_info->current_seq) 1003 { 1004 1005 /* PN544 Device pipe close sequence */ 1006 case DEV_MGMT_EVT_AUTONOMOUS: 1007 { 1008 p_pipe_info = p_device_mgmt_info->p_pipe_info; 1009 1010 p_pipe_info->param_info = NULL; 1011 p_pipe_info->param_length = HCP_ZERO_LEN; 1012 1013 status = phHciNfc_Send_DevMgmt_Event(psHciContext, pHwRef, 1014 p_pipe_info->pipe.pipe_id, NXP_EVT_SET_AUTONOMOUS); 1015 if(status == NFCSTATUS_PENDING) 1016 { 1017 p_device_mgmt_info->next_seq = DEV_MGMT_PIPE_OPEN; 1018 status = NFCSTATUS_SUCCESS; 1019 } 1020 break; 1021 } 1022 /* PN544 Device pipe close sequence */ 1023 case DEV_MGMT_PIPE_CLOSE: 1024 { 1025 p_pipe_info = p_device_mgmt_info->p_pipe_info; 1026 1027 status = phHciNfc_Close_Pipe( psHciContext, 1028 pHwRef, p_pipe_info ); 1029 if(status == NFCSTATUS_SUCCESS) 1030 { 1031 p_device_mgmt_info->next_seq = DEV_MGMT_PIPE_OPEN; 1032 /* status = NFCSTATUS_PENDING; */ 1033 } 1034 break; 1035 } 1036 default: 1037 { 1038 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE); 1039 break; 1040 } 1041 1042 }/* End of the Sequence Switch */ 1043 1044 }/* End of the PN544 Device Info Memory Check */ 1045 1046 } /* End of Null Context Check */ 1047 1048 return status; 1049 } 1050 1051 NFCSTATUS 1052 phHciNfc_DevMgmt_Update_Sequence( 1053 phHciNfc_sContext_t *psHciContext, 1054 phHciNfc_eSeqType_t DevMgmt_seq 1055 ) 1056 { 1057 NFCSTATUS status = NFCSTATUS_SUCCESS; 1058 phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL; 1059 if( NULL == psHciContext ) 1060 { 1061 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1062 } 1063 else if ( NULL == psHciContext->p_device_mgmt_info ) 1064 { 1065 status = PHNFCSTVAL(CID_NFC_HCI, 1066 NFCSTATUS_INVALID_HCI_INFORMATION); 1067 } 1068 else 1069 { 1070 p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *) 1071 psHciContext->p_device_mgmt_info ; 1072 switch(DevMgmt_seq) 1073 { 1074 case RESET_SEQ: 1075 case INIT_SEQ: 1076 { 1077 p_device_mgmt_info->current_seq = DEV_MGMT_PIPE_OPEN; 1078 p_device_mgmt_info->next_seq = DEV_MGMT_PIPE_OPEN ; 1079 break; 1080 } 1081 case UPDATE_SEQ: 1082 { 1083 p_device_mgmt_info->current_seq = p_device_mgmt_info->next_seq; 1084 1085 break; 1086 } 1087 case REL_SEQ: 1088 { 1089 p_device_mgmt_info->current_seq = DEV_MGMT_EVT_AUTONOMOUS; 1090 p_device_mgmt_info->next_seq = DEV_MGMT_EVT_AUTONOMOUS ; 1091 break; 1092 } 1093 default: 1094 { 1095 break; 1096 } 1097 }/* End of Update Sequence Switch */ 1098 } 1099 return status; 1100 1101 } 1102 1103 1104 1105 /*! 1106 * \brief Perform the System Management Tests 1107 * provided by the corresponding peripheral device. 1108 * 1109 * This function performs the System Management Tests provided by the NFC 1110 * Peripheral device. 1111 */ 1112 1113 NFCSTATUS 1114 phHciNfc_DevMgmt_Test( 1115 void *psContext, 1116 void *pHwRef, 1117 uint8_t test_type, 1118 phNfc_sData_t *test_param 1119 ) 1120 { 1121 phHciNfc_sContext_t *psHciContext = 1122 (phHciNfc_sContext_t *)psContext ; 1123 NFCSTATUS status = NFCSTATUS_SUCCESS; 1124 phHciNfc_Pipe_Info_t *p_pipe_info = NULL; 1125 uint8_t pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID; 1126 1127 if( (NULL == psHciContext) || (NULL == pHwRef) ) 1128 { 1129 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1130 } 1131 else if( NULL == psHciContext->p_device_mgmt_info ) 1132 { 1133 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 1134 } 1135 else 1136 { 1137 phHciNfc_DevMgmt_Info_t *p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *) 1138 psHciContext->p_device_mgmt_info ; 1139 p_pipe_info = ((phHciNfc_DevMgmt_Info_t *) 1140 psHciContext->p_device_mgmt_info)->p_pipe_info ; 1141 switch(test_type) 1142 { 1143 case NXP_SELF_TEST_ANTENNA: 1144 case NXP_SELF_TEST_SWP: 1145 case NXP_SELF_TEST_PRBS: 1146 /* case NXP_SELF_TEST_NFCWI: */ 1147 { 1148 if (NULL != p_pipe_info) 1149 { 1150 pipe_id = p_pipe_info->pipe.pipe_id ; 1151 if ( NULL != test_param ) 1152 { 1153 p_pipe_info->param_info = test_param->buffer; 1154 p_pipe_info->param_length = (uint8_t)test_param->length; 1155 } 1156 p_device_mgmt_info->test_result.buffer = NULL; 1157 p_device_mgmt_info->test_result.length = 0; 1158 status = 1159 phHciNfc_Send_DevMgmt_Command( psHciContext, pHwRef, 1160 pipe_id, (uint8_t)test_type ); 1161 } 1162 else 1163 { 1164 status = PHNFCSTVAL(CID_NFC_HCI, 1165 NFCSTATUS_INVALID_HCI_INFORMATION); 1166 } 1167 break; 1168 } 1169 default: 1170 { 1171 status = PHNFCSTVAL(CID_NFC_HCI, 1172 NFCSTATUS_FEATURE_NOT_SUPPORTED); 1173 break; 1174 } 1175 } 1176 1177 } 1178 return status; 1179 } 1180 1181 1182 /*! 1183 * \brief Receives the HCI Response from the corresponding peripheral device. 1184 * 1185 * This function receives the HCI Command Response from the connected NFC 1186 * Peripheral device. 1187 */ 1188 static 1189 NFCSTATUS 1190 phHciNfc_Recv_DevMgmt_Response( 1191 void *psContext, 1192 void *pHwRef, 1193 uint8_t *pResponse, 1194 #ifdef ONE_BYTE_LEN 1195 uint8_t length 1196 #else 1197 uint16_t length 1198 #endif 1199 ) 1200 { 1201 phHciNfc_sContext_t *psHciContext = 1202 (phHciNfc_sContext_t *)psContext ; 1203 phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL; 1204 NFCSTATUS status = NFCSTATUS_SUCCESS; 1205 uint8_t prev_cmd = ANY_GET_PARAMETER; 1206 1207 if( (NULL == psHciContext) || (NULL == pHwRef) ) 1208 { 1209 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1210 } 1211 else if( NULL == psHciContext->p_device_mgmt_info ) 1212 { 1213 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 1214 } 1215 else 1216 { 1217 p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *) 1218 psHciContext->p_device_mgmt_info ; 1219 prev_cmd = p_device_mgmt_info->p_pipe_info->prev_msg ; 1220 switch(prev_cmd) 1221 { 1222 case ANY_GET_PARAMETER: 1223 { 1224 status = phHciNfc_DevMgmt_InfoUpdate(psHciContext, 1225 (phHal_sHwReference_t *)pHwRef, 1226 p_device_mgmt_info->p_pipe_info->reg_index, 1227 &pResponse[HCP_HEADER_LEN], 1228 (uint8_t)(length - HCP_HEADER_LEN)); 1229 break; 1230 } 1231 case ANY_SET_PARAMETER: 1232 { 1233 break; 1234 } 1235 case ANY_OPEN_PIPE: 1236 { 1237 break; 1238 } 1239 case ANY_CLOSE_PIPE: 1240 { 1241 phOsalNfc_FreeMemory(p_device_mgmt_info->p_pipe_info); 1242 p_device_mgmt_info->p_pipe_info = NULL; 1243 psHciContext->p_pipe_list[PIPETYPE_STATIC_LINK] = NULL; 1244 break; 1245 } 1246 case NXP_DBG_READ: 1247 /* fall through */ 1248 case NXP_DBG_WRITE: 1249 { 1250 if( NULL != p_device_mgmt_info->p_val ) 1251 { 1252 *p_device_mgmt_info->p_val = (uint8_t)( length > HCP_HEADER_LEN ) ? 1253 pResponse[HCP_HEADER_LEN]: 0; 1254 p_device_mgmt_info->p_val = NULL; 1255 } 1256 break; 1257 } 1258 /* Self Test Commands */ 1259 case NXP_SELF_TEST_ANTENNA: 1260 case NXP_SELF_TEST_SWP: 1261 case NXP_SELF_TEST_NFCWI: 1262 case NXP_SELF_TEST_PRBS: 1263 { 1264 p_device_mgmt_info->test_status = (uint8_t) ( length > HCP_HEADER_LEN ) ? 1265 pResponse[HCP_HEADER_LEN]: 0; 1266 p_device_mgmt_info->test_result.buffer = (uint8_t)( length > HCP_HEADER_LEN ) ? 1267 &pResponse[HCP_HEADER_LEN]: NULL; 1268 p_device_mgmt_info->test_result.length = ( length - HCP_HEADER_LEN ); 1269 break; 1270 } 1271 default: 1272 { 1273 status = PHNFCSTVAL(CID_NFC_HCI, 1274 NFCSTATUS_INVALID_HCI_RESPONSE); 1275 break; 1276 } 1277 } 1278 if( NFCSTATUS_SUCCESS == status ) 1279 { 1280 if( NULL != p_device_mgmt_info->p_pipe_info) 1281 { 1282 p_device_mgmt_info->p_pipe_info->prev_status = NFCSTATUS_SUCCESS; 1283 } 1284 p_device_mgmt_info->current_seq = p_device_mgmt_info->next_seq; 1285 } 1286 1287 } 1288 return status; 1289 } 1290 1291 /*! 1292 * \brief Receives the HCI Event from the corresponding peripheral device. 1293 * 1294 * This function receives the HCI Event from the connected NFC 1295 * Peripheral device. 1296 */ 1297 1298 static 1299 NFCSTATUS 1300 phHciNfc_Recv_DevMgmt_Event( 1301 void *psContext, 1302 void *pHwRef, 1303 uint8_t *pEvent, 1304 #ifdef ONE_BYTE_LEN 1305 uint8_t length 1306 #else 1307 uint16_t length 1308 #endif 1309 ) 1310 { 1311 phHciNfc_sContext_t *psHciContext = 1312 (phHciNfc_sContext_t *)psContext ; 1313 phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL; 1314 phHciNfc_HCP_Packet_t *hcp_packet = NULL; 1315 phHciNfc_HCP_Message_t *hcp_message = NULL; 1316 NFCSTATUS status = NFCSTATUS_SUCCESS; 1317 phHal_sEventInfo_t event_info; 1318 uint8_t event = (uint8_t) HCP_MSG_INSTRUCTION_INVALID; 1319 1320 if( (NULL == psHciContext) || (NULL == pHwRef) ) 1321 { 1322 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1323 } 1324 else if( NULL == psHciContext->p_device_mgmt_info ) 1325 { 1326 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED); 1327 } 1328 else 1329 { 1330 p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *) 1331 psHciContext->p_device_mgmt_info ; 1332 hcp_packet = (phHciNfc_HCP_Packet_t *)pEvent; 1333 hcp_message = &hcp_packet->msg.message; 1334 1335 /* Get the Event instruction bits from the Message Header */ 1336 event = (uint8_t) GET_BITS8( hcp_message->msg_header, 1337 HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN); 1338 event_info.eventHost = phHal_eHostController ; 1339 event_info.eventSource = phHal_ePCD_DevType; 1340 1341 switch(event) 1342 { 1343 /* Information Events */ 1344 case NXP_EVT_INFO_TXLDO_OVERCUR: 1345 { 1346 event_info.eventType = NFC_INFO_TXLDO_OVERCUR; 1347 break; 1348 } 1349 case NXP_EVT_INFO_PMUVCC: 1350 { 1351 p_device_mgmt_info->pmuvcc_status = (uint8_t) ( length > HCP_HEADER_LEN ) ? 1352 pEvent[HCP_HEADER_LEN]: 0; 1353 break; 1354 } 1355 case NXP_EVT_INFO_EXT_RF_FIELD: 1356 { 1357 event_info.eventSource = phHal_ePICC_DevType ; 1358 p_device_mgmt_info->rf_status = (uint8_t) ( length > HCP_HEADER_LEN ) ? 1359 pEvent[HCP_HEADER_LEN]: 0; 1360 #ifdef EVT_INFO_EXT_EVT_DIRECT 1361 event_info.eventType = ( CE_EVT_NFC_FIELD_ON == 1362 (p_device_mgmt_info->rf_status & 0x1FU))? 1363 NFC_EVT_FIELD_ON : NFC_EVT_FIELD_OFF; 1364 #else 1365 event_info.eventType = (TRUE == p_device_mgmt_info->rf_status)? 1366 NFC_EVT_FIELD_ON : NFC_EVT_FIELD_OFF; 1367 #endif 1368 break; 1369 } 1370 case NXP_EVT_INFO_MEM_VIOLATION: 1371 { 1372 event_info.eventType = NFC_INFO_MEM_VIOLATION; 1373 ALOGW("Your NFC controller is kinda hosed, take it to npelly@ to fix"); 1374 break; 1375 } 1376 case NXP_EVT_INFO_TEMP_OVERHEAT: 1377 { 1378 p_device_mgmt_info->overheat_status = (uint8_t)( length > HCP_HEADER_LEN ) ? 1379 pEvent[HCP_HEADER_LEN]: 0; 1380 event_info.eventType = NFC_INFO_TEMP_OVERHEAT; 1381 event_info.eventInfo.overheat_status = 1382 p_device_mgmt_info->overheat_status; 1383 break; 1384 } 1385 case NXP_EVT_INFO_LLC_ERROR: 1386 { 1387 event_info.eventType = NFC_INFO_LLC_ERROR; 1388 break; 1389 } 1390 default: 1391 { 1392 status = PHNFCSTVAL(CID_NFC_HCI, 1393 NFCSTATUS_INVALID_HCI_RESPONSE); 1394 break; 1395 } 1396 } 1397 if( NFCSTATUS_SUCCESS == status ) 1398 { 1399 if( NULL != p_device_mgmt_info->p_pipe_info) 1400 { 1401 p_device_mgmt_info->p_pipe_info->prev_status = 1402 NFCSTATUS_SUCCESS; 1403 } 1404 p_device_mgmt_info->current_seq = 1405 p_device_mgmt_info->next_seq; 1406 phHciNfc_Notify_Event(psHciContext, pHwRef, 1407 NFC_NOTIFY_EVENT, &event_info); 1408 } 1409 } 1410 return status; 1411 } 1412 1413 1414 static 1415 NFCSTATUS 1416 phHciNfc_DevMgmt_InfoUpdate( 1417 phHciNfc_sContext_t *psHciContext, 1418 phHal_sHwReference_t *pHwRef, 1419 uint8_t index, 1420 uint8_t *reg_value, 1421 uint8_t reg_length 1422 ) 1423 { 1424 phHciNfc_DevMgmt_Info_t *p_device_mgmt_info=NULL; 1425 NFCSTATUS status = NFCSTATUS_SUCCESS; 1426 uint8_t i=0; 1427 1428 PHNFC_UNUSED_VARIABLE(pHwRef); 1429 if( (NULL == psHciContext) 1430 || (NULL == reg_value) 1431 || (reg_length == 0) 1432 ) 1433 { 1434 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1435 } 1436 else if ( NULL == psHciContext->p_device_mgmt_info ) 1437 { 1438 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION); 1439 } 1440 else 1441 { 1442 p_device_mgmt_info = (phHciNfc_DevMgmt_Info_t *) 1443 psHciContext->p_device_mgmt_info ; 1444 1445 switch(index) 1446 { 1447 case DEVICE_INFO_EEPROM_INDEX: 1448 { 1449 p_device_mgmt_info->eeprom_crc = reg_value[i]; 1450 break; 1451 } 1452 default: 1453 { 1454 break; 1455 } 1456 } 1457 1458 } /* End of Context and the PN544 Device information validity check */ 1459 1460 return status; 1461 } 1462 1463 1464 1465 /*! 1466 * \brief Sends the RF Settings HCI Additonal Commands to the connected 1467 * reader device. 1468 * 1469 * This function Sends the RF Settings HCI Command frames in the HCP packet 1470 * format to the connected reader device. 1471 */ 1472 static 1473 NFCSTATUS 1474 phHciNfc_Send_DevMgmt_Command ( 1475 phHciNfc_sContext_t *psHciContext, 1476 void *pHwRef, 1477 uint8_t pipe_id, 1478 uint8_t cmd 1479 ) 1480 { 1481 phHciNfc_HCP_Packet_t *hcp_packet = NULL; 1482 phHciNfc_HCP_Message_t *hcp_message = NULL; 1483 phHciNfc_Pipe_Info_t *p_pipe_info = NULL; 1484 uint8_t length=0; 1485 uint8_t i = 0; 1486 NFCSTATUS status = NFCSTATUS_SUCCESS; 1487 1488 if( (NULL == psHciContext) 1489 || ( pipe_id > PHHCINFC_MAX_PIPE) 1490 ||(NULL == psHciContext->p_pipe_list[pipe_id]) 1491 ) 1492 { 1493 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1494 HCI_DEBUG("%s: Invalid Arguments passed \n", 1495 "phHciNfc_Send_DevMgmt_Command"); 1496 } 1497 else 1498 { 1499 p_pipe_info = (phHciNfc_Pipe_Info_t *) 1500 psHciContext->p_pipe_list[pipe_id]; 1501 psHciContext->tx_total = 0 ; 1502 length += HCP_HEADER_LEN ; 1503 switch( cmd ) 1504 { 1505 /* Self Test Commands */ 1506 case NXP_SELF_TEST_ANTENNA: 1507 case NXP_SELF_TEST_SWP: 1508 case NXP_SELF_TEST_NFCWI: 1509 case NXP_SELF_TEST_PRBS: 1510 /* Internal Properietary Commands */ 1511 case NXP_DBG_READ: 1512 case NXP_DBG_WRITE: 1513 { 1514 1515 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer; 1516 /* Construct the HCP Frame */ 1517 phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT, 1518 (uint8_t) pipe_id, HCP_MSG_TYPE_COMMAND, cmd); 1519 hcp_message = &(hcp_packet->msg.message); 1520 /* Append the RF Setting Parameter also the optional Value */ 1521 phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload, 1522 i, p_pipe_info->param_info, 1523 p_pipe_info->param_length); 1524 length =(uint8_t)(length + i + p_pipe_info->param_length); 1525 break; 1526 } 1527 default: 1528 { 1529 status = PHNFCSTVAL( CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED ); 1530 HCI_DEBUG("%s: Statement Should Not Occur \n", 1531 "phHciNfc_Send_DevMgmt_Command"); 1532 break; 1533 } 1534 } 1535 if( NFCSTATUS_SUCCESS == status ) 1536 { 1537 p_pipe_info->sent_msg_type = HCP_MSG_TYPE_COMMAND; 1538 p_pipe_info->prev_msg = cmd; 1539 psHciContext->tx_total = length; 1540 psHciContext->response_pending = TRUE ; 1541 1542 /* Send the Constructed HCP packet to the lower layer */ 1543 status = phHciNfc_Send_HCP( psHciContext, pHwRef ); 1544 p_pipe_info->prev_status = NFCSTATUS_PENDING; 1545 } 1546 } 1547 1548 return status; 1549 } 1550 1551 1552 1553 /*! 1554 * \brief Sends the RF Settings HCI Additonal Events to the connected 1555 * reader device. 1556 * 1557 * This function Sends the RF Settings HCI Events frames in the HCP packet 1558 * format to the connected reader device. 1559 */ 1560 1561 static 1562 NFCSTATUS 1563 phHciNfc_Send_DevMgmt_Event ( 1564 phHciNfc_sContext_t *psHciContext, 1565 void *pHwRef, 1566 uint8_t pipe_id, 1567 uint8_t event 1568 ) 1569 { 1570 phHciNfc_HCP_Packet_t *hcp_packet = NULL; 1571 phHciNfc_HCP_Message_t *hcp_message = NULL; 1572 phHciNfc_Pipe_Info_t *p_pipe_info = NULL; 1573 uint8_t length=0; 1574 uint8_t i = 0; 1575 NFCSTATUS status = NFCSTATUS_SUCCESS; 1576 1577 if( (NULL == psHciContext) 1578 || ( pipe_id > PHHCINFC_MAX_PIPE) 1579 ||(NULL == psHciContext->p_pipe_list[pipe_id]) 1580 ) 1581 { 1582 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER); 1583 HCI_DEBUG("%s: Invalid Arguments passed \n", 1584 "phHciNfc_Send_DevMgmt_Event"); 1585 } 1586 else 1587 { 1588 p_pipe_info = (phHciNfc_Pipe_Info_t *) 1589 psHciContext->p_pipe_list[pipe_id]; 1590 psHciContext->tx_total = 0 ; 1591 length += HCP_HEADER_LEN ; 1592 if( NXP_EVT_SET_AUTONOMOUS == event ) 1593 { 1594 1595 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer; 1596 /* Construct the HCP Frame */ 1597 phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT, 1598 (uint8_t) pipe_id, HCP_MSG_TYPE_EVENT, event); 1599 hcp_message = &(hcp_packet->msg.message); 1600 /* Append the RF Setting Parameter also the optional Value */ 1601 phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload, 1602 i, p_pipe_info->param_info, 1603 p_pipe_info->param_length); 1604 length =(uint8_t)(length + i + p_pipe_info->param_length); 1605 } 1606 else 1607 { 1608 status = PHNFCSTVAL( CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED ); 1609 HCI_DEBUG("%s: Statement Should Not Occur \n", 1610 "phHciNfc_Send_DevMgmt_Event"); 1611 } 1612 if( NFCSTATUS_SUCCESS == status ) 1613 { 1614 p_pipe_info->sent_msg_type = HCP_MSG_TYPE_EVENT; 1615 p_pipe_info->prev_msg = event; 1616 psHciContext->tx_total = length; 1617 1618 /* Send the Constructed HCP packet to the lower layer */ 1619 status = phHciNfc_Send_HCP( psHciContext, pHwRef ); 1620 p_pipe_info->prev_status = NFCSTATUS_PENDING; 1621 } 1622 } 1623 1624 return status; 1625 } 1626 1627 1628 1629 1630 1631
