Home | History | Annotate | Download | only in src
      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 > NFCIP_ATR_MAX_LENGTH))
   1764     {
   1765         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
   1766     }
   1767     else if (NFCIP_INVALID == nfciptype)
   1768     {
   1769         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
   1770     }
   1771     else if(NULL == psHciContext->p_nfcip_info)
   1772     {
   1773         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
   1774     }
   1775     else
   1776     {
   1777         phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
   1778         phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
   1779         uint8_t                     pipeid = 0;
   1780 
   1781         p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
   1782                     psHciContext->p_nfcip_info ;
   1783         p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
   1784                         p_nfcipinfo->p_init_pipe_info:
   1785                         p_nfcipinfo->p_tgt_pipe_info);
   1786 
   1787         if(NULL == p_pipe_info )
   1788         {
   1789             status = PHNFCSTVAL(CID_NFC_HCI,
   1790                 NFCSTATUS_INVALID_HCI_INFORMATION);
   1791         }
   1792         else
   1793         {
   1794             pipeid = p_pipe_info->pipe.pipe_id ;
   1795             p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR == nfciptype)?
   1796                                         NXP_NFCIP_ATR_REQ :
   1797                                         NXP_NFCIP_ATR_RES);
   1798 
   1799             p_pipe_info->param_info = atr_info->generalBytes;
   1800             p_pipe_info->param_length = (uint8_t)
   1801                                         atr_info->generalBytesLength;
   1802             status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
   1803                                     pipeid, (uint8_t)ANY_SET_PARAMETER);
   1804         }
   1805     }
   1806     return status;
   1807 }
   1808 
   1809 NFCSTATUS
   1810 phHciNfc_NfcIP_SetPSL1(
   1811                           phHciNfc_sContext_t   *psHciContext,
   1812                           void                  *pHwRef,
   1813                           uint8_t               psl1
   1814                           )
   1815 {
   1816     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
   1817 
   1818     if( (NULL == psHciContext) || (NULL == pHwRef))
   1819     {
   1820         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
   1821     }
   1822     else if(NULL == psHciContext->p_nfcip_info)
   1823     {
   1824         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
   1825     }
   1826     else
   1827     {
   1828         phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
   1829         phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
   1830         uint8_t                     pipeid = 0;
   1831 
   1832         p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
   1833                         psHciContext->p_nfcip_info ;
   1834         p_pipe_info = p_nfcipinfo->p_init_pipe_info;
   1835 
   1836         if(NULL == p_pipe_info )
   1837         {
   1838             status = PHNFCSTVAL(CID_NFC_HCI,
   1839                 NFCSTATUS_INVALID_HCI_INFORMATION);
   1840         }
   1841         else
   1842         {
   1843             pipeid = p_pipe_info->pipe.pipe_id ;
   1844             p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PSL1;
   1845 
   1846             p_pipe_info->param_info = &psl1;
   1847             p_pipe_info->param_length = sizeof(uint8_t);
   1848             status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
   1849                                 pipeid, (uint8_t)ANY_SET_PARAMETER);
   1850         }
   1851     }
   1852     return status;
   1853 }
   1854 
   1855 NFCSTATUS
   1856 phHciNfc_NfcIP_SetPSL2(
   1857                        phHciNfc_sContext_t  *psHciContext,
   1858                        void                 *pHwRef,
   1859                        uint8_t              psl2
   1860                           )
   1861 {
   1862     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
   1863 
   1864     if( (NULL == psHciContext) || (NULL == pHwRef))
   1865     {
   1866         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
   1867     }
   1868     else if(NULL == psHciContext->p_nfcip_info)
   1869     {
   1870         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
   1871     }
   1872     else
   1873     {
   1874         phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
   1875         phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
   1876         uint8_t                     pipeid = 0;
   1877 
   1878         p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
   1879                         psHciContext->p_nfcip_info ;
   1880         p_pipe_info = p_nfcipinfo->p_init_pipe_info;
   1881 
   1882         if(NULL == p_pipe_info )
   1883         {
   1884             status = PHNFCSTVAL(CID_NFC_HCI,
   1885                 NFCSTATUS_INVALID_HCI_INFORMATION);
   1886         }
   1887         else
   1888         {
   1889             pipeid = p_pipe_info->pipe.pipe_id ;
   1890             p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PSL2;
   1891 
   1892             p_pipe_info->param_info = &psl2;
   1893             p_pipe_info->param_length = sizeof(uint8_t);
   1894             status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
   1895                                     pipeid, (uint8_t)ANY_SET_PARAMETER);
   1896         }
   1897     }
   1898     return status;
   1899 }
   1900 
   1901 NFCSTATUS
   1902 phHciNfc_NfcIP_GetStatus(
   1903                        phHciNfc_sContext_t      *psHciContext,
   1904                        void                     *pHwRef,
   1905                        phHciNfc_eNfcIPType_t    nfciptype
   1906                           )
   1907 {
   1908     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
   1909 
   1910     if( (NULL == psHciContext) || (NULL == pHwRef))
   1911     {
   1912         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
   1913     }
   1914     else if (NFCIP_INVALID == nfciptype)
   1915     {
   1916         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
   1917     }
   1918     else if(NULL == psHciContext->p_nfcip_info)
   1919     {
   1920         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
   1921     }
   1922     else
   1923     {
   1924         phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
   1925         phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
   1926         uint8_t                     pipeid = 0;
   1927 
   1928         p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
   1929                         psHciContext->p_nfcip_info ;
   1930         p_pipe_info =  ((NFCIP_INITIATOR == nfciptype)?
   1931                         p_nfcipinfo->p_init_pipe_info :
   1932                         p_nfcipinfo->p_tgt_pipe_info);
   1933         if(NULL == p_pipe_info )
   1934         {
   1935             status = PHNFCSTVAL(CID_NFC_HCI,
   1936                                 NFCSTATUS_INVALID_HCI_INFORMATION);
   1937         }
   1938         else
   1939         {
   1940             pipeid = p_pipe_info->pipe.pipe_id ;
   1941             p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_STATUS;
   1942 
   1943             status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
   1944                                         pipeid, (uint8_t)ANY_GET_PARAMETER);
   1945         }
   1946     }
   1947     return status;
   1948 }
   1949 
   1950 NFCSTATUS
   1951 phHciNfc_NfcIP_GetParam(
   1952                          phHciNfc_sContext_t    *psHciContext,
   1953                          void                   *pHwRef,
   1954                          phHciNfc_eNfcIPType_t  nfciptype
   1955                          )
   1956 {
   1957     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
   1958 
   1959     if( (NULL == psHciContext) || (NULL == pHwRef))
   1960     {
   1961         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
   1962     }
   1963     else if (NFCIP_INVALID == nfciptype)
   1964     {
   1965         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
   1966     }
   1967     else if(NULL == psHciContext->p_nfcip_info)
   1968     {
   1969         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
   1970     }
   1971     else
   1972     {
   1973         phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
   1974         phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
   1975         uint8_t                     pipeid = 0;
   1976 
   1977         p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
   1978                         psHciContext->p_nfcip_info ;
   1979         p_pipe_info =  ((NFCIP_INITIATOR == nfciptype)?
   1980                         p_nfcipinfo->p_init_pipe_info :
   1981                         p_nfcipinfo->p_tgt_pipe_info);
   1982         if(NULL == p_pipe_info )
   1983         {
   1984             status = PHNFCSTVAL(CID_NFC_HCI,
   1985                                 NFCSTATUS_INVALID_HCI_INFORMATION);
   1986         }
   1987         else
   1988         {
   1989             pipeid = p_pipe_info->pipe.pipe_id ;
   1990             p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PARAM;
   1991 
   1992             status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
   1993                                     pipeid, (uint8_t)ANY_GET_PARAMETER);
   1994         }
   1995     }
   1996     return status;
   1997 }
   1998 
   1999 NFCSTATUS
   2000 phHciNfc_Initiator_Cont_Activate (
   2001                                 phHciNfc_sContext_t       *psHciContext,
   2002                                 void                      *pHwRef
   2003                                 )
   2004 {
   2005     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
   2006 
   2007     if( (NULL == psHciContext) || (NULL == pHwRef) )
   2008     {
   2009         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
   2010     }
   2011     else if(NULL == psHciContext->p_nfcip_info)
   2012     {
   2013         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
   2014     }
   2015     else
   2016     {
   2017         phHciNfc_NfcIP_Info_t     *p_nfcipinfo = NULL;
   2018         phHciNfc_Pipe_Info_t      *p_pipe_info=NULL;
   2019 
   2020         p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
   2021                         psHciContext->p_nfcip_info ;
   2022         p_nfcipinfo->nfcip_type = NFCIP_INITIATOR;
   2023         psHciContext->host_rf_type = phHal_eNfcIP1_Initiator;
   2024         p_pipe_info =  p_nfcipinfo->p_init_pipe_info;
   2025         if(NULL == p_pipe_info )
   2026         {
   2027             status = PHNFCSTVAL(CID_NFC_HCI,
   2028                                 NFCSTATUS_INVALID_HCI_INFORMATION);
   2029         }
   2030         else
   2031         {
   2032             phHciNfc_HCP_Packet_t       *hcp_packet = NULL;
   2033             uint16_t                    length = HCP_HEADER_LEN;
   2034             uint8_t                     pipeid = 0;
   2035 
   2036             pipeid = p_pipe_info->pipe.pipe_id;
   2037             psHciContext->tx_total = 0 ;
   2038             hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
   2039             /* Construct the HCP Frame */
   2040             phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT,
   2041                             (uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_COMMAND,
   2042                             (uint8_t)NXP_NFCI_CONTINUE_ACTIVATION);
   2043 
   2044             p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_COMMAND;
   2045             p_pipe_info->prev_msg = (uint8_t)NXP_NFCI_CONTINUE_ACTIVATION;
   2046             psHciContext->tx_total = length;
   2047             psHciContext->response_pending = (uint8_t)TRUE;
   2048 
   2049             /* Send the Constructed HCP packet to the lower layer */
   2050             status = phHciNfc_Send_HCP( psHciContext, pHwRef);
   2051             p_pipe_info->prev_status = status;
   2052         }
   2053     }
   2054     return status;
   2055 }
   2056 
   2057 
   2058 NFCSTATUS
   2059 phHciNfc_NfcIP_GetATRInfo (
   2060                            phHciNfc_sContext_t      *psHciContext,
   2061                            void                     *pHwRef,
   2062                            phHciNfc_eNfcIPType_t    nfciptype
   2063                            )
   2064 {
   2065     NFCSTATUS               status = NFCSTATUS_SUCCESS;
   2066 
   2067     if( (NULL == psHciContext)
   2068         || (NULL == pHwRef))
   2069     {
   2070         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
   2071     }
   2072     else if (NFCIP_INVALID == nfciptype)
   2073     {
   2074         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
   2075     }
   2076     else if(NULL == psHciContext->p_nfcip_info)
   2077     {
   2078         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
   2079     }
   2080     else
   2081     {
   2082         phHciNfc_NfcIP_Info_t       *p_nfcipinfo=NULL;
   2083         phHciNfc_Pipe_Info_t        *p_pipe_info=NULL;
   2084         uint8_t                     pipeid = 0;
   2085 
   2086         p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
   2087                         psHciContext->p_nfcip_info ;
   2088 
   2089         p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
   2090                         p_nfcipinfo->p_init_pipe_info :
   2091                         p_nfcipinfo->p_tgt_pipe_info);
   2092 
   2093         if(NULL == p_pipe_info )
   2094         {
   2095             status = PHNFCSTVAL(CID_NFC_HCI,
   2096                                 NFCSTATUS_INVALID_HCI_INFORMATION);
   2097         }
   2098         else
   2099         {
   2100             p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR == nfciptype)?
   2101                                     NXP_NFCIP_ATR_RES :
   2102                                     NXP_NFCIP_ATR_REQ);
   2103             pipeid = p_pipe_info->pipe.pipe_id ;
   2104             /* Fill the data buffer and send the command to the
   2105                 device */
   2106             status =
   2107                 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
   2108                 pipeid, (uint8_t)ANY_GET_PARAMETER);
   2109         }
   2110     }
   2111     return status;
   2112 }
   2113 
   2114 NFCSTATUS
   2115 phHciNfc_NfcIP_SetMergeSak(
   2116                             phHciNfc_sContext_t     *psHciContext,
   2117                             void                    *pHwRef,
   2118                             uint8_t                 sak_value
   2119                            )
   2120 {
   2121     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
   2122 
   2123     if( (NULL == psHciContext) || (NULL == pHwRef) ||
   2124         (sak_value > (uint8_t)TRUE))
   2125     {
   2126         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
   2127     }
   2128     else if(NULL == psHciContext->p_nfcip_info)
   2129     {
   2130         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
   2131     }
   2132     else
   2133     {
   2134         phHciNfc_NfcIP_Info_t       *ps_nfcipinfo=NULL;
   2135         phHciNfc_Pipe_Info_t        *ps_pipe_info=NULL;
   2136         uint8_t                     pipeid = 0;
   2137 
   2138         ps_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
   2139                         psHciContext->p_nfcip_info ;
   2140         ps_pipe_info = ps_nfcipinfo->p_tgt_pipe_info;
   2141 
   2142         if(NULL == ps_pipe_info )
   2143         {
   2144             status = PHNFCSTVAL(CID_NFC_HCI,
   2145                                 NFCSTATUS_INVALID_HCI_INFORMATION);
   2146         }
   2147         else
   2148         {
   2149             pipeid = ps_pipe_info->pipe.pipe_id ;
   2150             ps_pipe_info->reg_index = (uint8_t)NXP_NFCIP_MERGE;
   2151 
   2152             ps_pipe_info->param_info = &sak_value;
   2153             ps_pipe_info->param_length = sizeof(uint8_t);
   2154             status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
   2155                                     pipeid, (uint8_t)ANY_SET_PARAMETER);
   2156         }
   2157     }
   2158     return status;
   2159 }
   2160 
   2161 #endif /* #if defined (ENABLE_P2P) */
   2162 
   2163