src/phHciNfc_SWP.c

   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_SWP.c                                                       *
  22 * \brief HCI SWP gate Management Routines.                                     *
  23 *                                                                             *
  24 *                                                                             *
  25 * Project: NFC-FRI-1.1                                                        *
  26 *                                                                             *
  27 * $Date: Tue Aug 18 10:16:36 2009 $                                           *
  28 * $Author: ing04880 $                                                         *
  29 * $Revision: 1.31 $                                                            *
  30 * $Aliases: NFC_FRI1.1_WK934_R31_1,NFC_FRI1.1_WK941_PREP1,NFC_FRI1.1_WK941_PREP2,NFC_FRI1.1_WK941_1,NFC_FRI1.1_WK943_R32_1,NFC_FRI1.1_WK949_PREP1,NFC_FRI1.1_WK943_R32_10,NFC_FRI1.1_WK943_R32_13,NFC_FRI1.1_WK943_R32_14,NFC_FRI1.1_WK1007_R33_1,NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $                                                                *                                                                             *
  31 * =========================================================================== *
  32 */
  33
  34 /*
  35 ***************************** Header File Inclusion ****************************
  36 */
  37 #include <phNfcCompId.h>
  38 #include <phHciNfc_Pipe.h>
  39 #include <phHciNfc_SWP.h>
  40 #include <phOsalNfc.h>
  41 #include <phHciNfc_Emulation.h>
  42 #include <phHciNfc_DevMgmt.h>
  43 /*
  44 ****************************** Macro Definitions *******************************
  45 */
  46
  47 /* SWP Gate regsitry Settings */
  48 /* set default mode mode as virtual mode */
  49 #define NXP_SWP_DEFAULT_MODE_INDEX      (0x01U)
  50 /* Get the Status of the UICC Connection */
  51 #define NXP_SWP_STATUS_INDEX            (0x02U)
  52
  53 /* Configure the Secure Element Protected Mode */
  54 #define NXP_SWP_PROTECTED_INDEX         (0x03U)
  55
  56 /* Switch mode index */
  57 #define NXP_EVT_SWP_SWITCH_MODE         (0x03U)
  58
  59 /* Protected Event from the Host Controller */
  60 #define NXP_EVT_SWP_PROTECTED           (0x04U)
  61
  62 /****************** Structure and Enumeration ****************************/
  63
  64 /****************** Static Function Declaration **************************/
  65
  66 static
  67 NFCSTATUS
  68 phHciNfc_Recv_SWP_Response(
  69                             void        *psContext,
  70                             void        *pHwRef,
  71                             uint8_t     *pResponse,
  72 #ifdef ONE_BYTE_LEN
  73                             uint8_t     length
  74 #else
  75                             uint16_t    length
  76 #endif
  77                         );
  78
  79 static
  80 NFCSTATUS
  81 phHciNfc_Send_SWP_Event(
  82                        phHciNfc_sContext_t      *psHciContext,
  83                        void                     *pHwRef,
  84                        uint8_t                  pipe_id,
  85                        uint8_t                  event
  86                        );
  87
  88
  89 static
  90 NFCSTATUS
  91 phHciNfc_Recv_SWP_Event(
  92                         void                *psContext,
  93                         void                *pHwRef,
  94                         uint8_t             *pEvent,
  95 #ifdef ONE_BYTE_LEN
  96                        uint8_t               length
  97 #else
  98                        uint16_t              length
  99 #endif
 100                        );
 101
 102 static
 103 NFCSTATUS
 104 phHciNfc_SWP_InfoUpdate(
 105                                 phHciNfc_sContext_t     *psHciContext,
 106                                 uint8_t                 index,
 107                                 uint8_t                 *reg_value,
 108                                 uint8_t                 reg_length
 109                           );
 110
 111 /*
 112 *************************** Function Definitions ***************************
 113 */
 114
 115 NFCSTATUS
 116 phHciNfc_SWP_Get_PipeID(
 117                        phHciNfc_sContext_t        *psHciContext,
 118                        uint8_t                    *ppipe_id
 119                        )
 120 {
 121     NFCSTATUS         status = NFCSTATUS_SUCCESS;
 122
 123     if( (NULL != psHciContext)
 124         && ( NULL != ppipe_id )
 125         && ( NULL != psHciContext->p_swp_info )
 126         )
 127     {
 128         phHciNfc_SWP_Info_t     *p_swp_info=NULL;
 129         p_swp_info = (phHciNfc_SWP_Info_t *)
 130                         psHciContext->p_swp_info ;
 131         *ppipe_id =  p_swp_info->pipe_id  ;
 132     }
 133     else
 134     {
 135         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 136     }
 137     return status;
 138 }
 139
 140 NFCSTATUS
 141 phHciNfc_SWP_Init_Resources(phHciNfc_sContext_t *psHciContext)
 142 {
 143     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
 144     phHciNfc_SWP_Info_t         *ps_swp_info=NULL;
 145
 146     if( NULL == psHciContext )
 147     {
 148         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 149     }
 150     else
 151     {
 152         if(( NULL == psHciContext->p_swp_info ) &&
 153              (phHciNfc_Allocate_Resource((void **)(&ps_swp_info),
 154             sizeof(phHciNfc_SWP_Info_t))== NFCSTATUS_SUCCESS))
 155         {
 156             psHciContext->p_swp_info = ps_swp_info;
 157             ps_swp_info->current_seq = SWP_INVALID_SEQUENCE;
 158             ps_swp_info->next_seq = SWP_INVALID_SEQUENCE;
 159             ps_swp_info->pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
 160         }
 161         else
 162         {
 163             status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
 164         }
 165
 166     }
 167     return status;
 168 }
 169
 170
 171 NFCSTATUS
 172 phHciNfc_SWP_Update_PipeInfo(
 173                                   phHciNfc_sContext_t     *psHciContext,
 174                                   uint8_t                 pipeID,
 175                                   phHciNfc_Pipe_Info_t    *pPipeInfo
 176                                   )
 177 {
 178     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
 179
 180     if( NULL == psHciContext )
 181     {
 182         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 183     }
 184     else if(NULL == psHciContext->p_swp_info)
 185     {
 186         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
 187     }
 188     else
 189     {
 190         phHciNfc_SWP_Info_t     *ps_swp_info=NULL;
 191         ps_swp_info = (phHciNfc_SWP_Info_t *)
 192                                 psHciContext->p_swp_info ;
 193         /* Update the pipe_id of the SWP Gate obtained from HCI Response */
 194         ps_swp_info->pipe_id = pipeID;
 195         ps_swp_info->p_pipe_info = pPipeInfo;
 196         if (NULL != pPipeInfo)
 197         {
 198             /* Update the Response Receive routine of the SWP Gate */
 199             pPipeInfo->recv_resp = &phHciNfc_Recv_SWP_Response;
 200             pPipeInfo->recv_event =&phHciNfc_Recv_SWP_Event;
 201         }
 202     }
 203     return status;
 204 }
 205
 206
 207 static
 208 NFCSTATUS
 209 phHciNfc_Recv_SWP_Response(
 210                         void                *psContext,
 211                         void                *pHwRef,
 212                         uint8_t             *pResponse,
 213 #ifdef ONE_BYTE_LEN
 214                         uint8_t             length
 215 #else
 216                         uint16_t            length
 217 #endif
 218                        )
 219 {
 220     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
 221     phHciNfc_sContext_t         *psHciContext =
 222                                 (phHciNfc_sContext_t *)psContext ;
 223
 224
 225     if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse)
 226         || (length == 0))
 227     {
 228       status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 229     }
 230     else if(NULL == psHciContext->p_swp_info)
 231     {
 232         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
 233     }
 234     else
 235     {
 236         phHciNfc_SWP_Info_t     *ps_swp_info=NULL;
 237         uint8_t                 prev_cmd = ANY_GET_PARAMETER;
 238
 239         ps_swp_info = (phHciNfc_SWP_Info_t *)
 240                         psHciContext->p_swp_info ;
 241         if( NULL == ps_swp_info->p_pipe_info)
 242         {
 243             status = PHNFCSTVAL(CID_NFC_HCI,
 244                             NFCSTATUS_INVALID_HCI_INFORMATION);
 245         }
 246         else
 247         {
 248             prev_cmd = ps_swp_info->p_pipe_info->prev_msg ;
 249             switch(prev_cmd)
 250             {
 251                 case ANY_GET_PARAMETER:
 252                 {
 253                     HCI_PRINT(" Getting the SWP Parameter \n");
 254                     status = phHciNfc_SWP_InfoUpdate(psHciContext,
 255                                     ps_swp_info->p_pipe_info->reg_index,
 256                                     &pResponse[HCP_HEADER_LEN],
 257                                     (uint8_t)(length - HCP_HEADER_LEN));
 258
 259                     break;
 260                 }
 261                 case ANY_SET_PARAMETER:
 262                 {
 263                     HCI_PRINT("SWP Parameter Set \n");
 264                     break;
 265                 }
 266                 case ANY_OPEN_PIPE:
 267                 {
 268                     HCI_PRINT("SWP gate open pipe complete\n");
 269                     break;
 270                 }
 271                 case ANY_CLOSE_PIPE:
 272                 {
 273                     HCI_PRINT("SWP close pipe complete\n");
 274                     break;
 275                 }
 276                 default:
 277                 {
 278                     status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
 279                     break;
 280                 }
 281             }
 282             if( NFCSTATUS_SUCCESS == status )
 283             {
 284                 status = phHciNfc_EmuMgmt_Update_Seq(psHciContext,
 285                                                     UPDATE_SEQ);
 286                 ps_swp_info->p_pipe_info->prev_status = NFCSTATUS_SUCCESS;
 287                 ps_swp_info->current_seq = ps_swp_info->next_seq;
 288             }
 289         }
 290     }
 291     return status;
 292 }
 293
 294
 295 NFCSTATUS
 296 phHciNfc_SWP_Configure_Default(
 297                             void        *psHciHandle,
 298                             void        *pHwRef,
 299                             uint8_t     enable_type
 300                         )
 301 {
 302     NFCSTATUS               status = NFCSTATUS_SUCCESS;
 303     static uint8_t          param = 0 ;
 304     phHciNfc_sContext_t     *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 305
 306     if((NULL == psHciContext)||(NULL == pHwRef))
 307     {
 308         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 309     }
 310     else if(NULL == psHciContext->p_swp_info)
 311     {
 312         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
 313     }
 314     else
 315     {
 316         phHciNfc_SWP_Info_t         *ps_swp_info=NULL;
 317         phHciNfc_Pipe_Info_t        *ps_pipe_info=NULL;
 318
 319         ps_swp_info = (phHciNfc_SWP_Info_t*)psHciContext->p_swp_info;
 320         ps_pipe_info = ps_swp_info->p_pipe_info;
 321
 322         if(NULL == ps_pipe_info)
 323         {
 324             status = PHNFCSTVAL(CID_NFC_HCI,
 325                                 NFCSTATUS_INVALID_HCI_INFORMATION);
 326         }
 327         else
 328         {
 329             ps_pipe_info->reg_index = NXP_SWP_DEFAULT_MODE_INDEX;
 330             /* Enable/Disable SWP link */
 331             param = (uint8_t)enable_type;
 332             ps_pipe_info->param_info =(void*)&param ;
 333             ps_pipe_info->param_length = sizeof(param) ;
 334             status = phHciNfc_Send_Generic_Cmd(psHciContext, pHwRef,
 335                                         ps_swp_info->pipe_id,
 336                                         (uint8_t)ANY_SET_PARAMETER);
 337         }
 338
 339     }
 340     return status;
 341 }
 342
 343
 344 NFCSTATUS
 345 phHciNfc_SWP_Get_Status(
 346                             void        *psHciHandle,
 347                             void        *pHwRef
 348                         )
 349 {
 350     NFCSTATUS               status = NFCSTATUS_SUCCESS;
 351     /* static uint8_t       param = 0 ; */
 352     phHciNfc_sContext_t     *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 353
 354     if((NULL == psHciContext)||(NULL == pHwRef))
 355     {
 356         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 357     }
 358     else if(NULL == psHciContext->p_swp_info)
 359     {
 360         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
 361     }
 362     else
 363     {
 364         phHciNfc_SWP_Info_t         *ps_swp_info=NULL;
 365         phHciNfc_Pipe_Info_t        *ps_pipe_info=NULL;
 366
 367         ps_swp_info = (phHciNfc_SWP_Info_t*)psHciContext->p_swp_info;
 368         ps_pipe_info = ps_swp_info->p_pipe_info;
 369
 370         if(NULL == ps_pipe_info)
 371         {
 372             status = PHNFCSTVAL(CID_NFC_HCI,
 373                                 NFCSTATUS_INVALID_HCI_INFORMATION);
 374         }
 375         else
 376         {
 377             ps_pipe_info->reg_index = NXP_SWP_STATUS_INDEX;
 378             status = phHciNfc_Send_Generic_Cmd(psHciContext, pHwRef,
 379                                     ps_swp_info->pipe_id,
 380                                     (uint8_t)ANY_GET_PARAMETER);
 381         }
 382     }
 383     return status;
 384 }
 385
 386
 387 NFCSTATUS
 388 phHciNfc_SWP_Get_Bitrate(
 389                             void        *psHciHandle,
 390                             void        *pHwRef
 391                         )
 392 {
 393     NFCSTATUS               status = NFCSTATUS_SUCCESS;
 394     phHciNfc_sContext_t     *psHciContext = ((phHciNfc_sContext_t *)
 395                                             psHciHandle);
 396
 397     if((NULL == psHciContext) || (NULL == pHwRef))
 398     {
 399         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 400     }
 401     else if(NULL == psHciContext->p_swp_info)
 402     {
 403         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
 404     }
 405     else
 406     {
 407         phHciNfc_SWP_Info_t         *ps_swp_info = NULL;
 408
 409         ps_swp_info = (phHciNfc_SWP_Info_t*)psHciContext->p_swp_info;
 410
 411         status = phHciNfc_DevMgmt_Get_Info(psHciContext, pHwRef,
 412                     NFC_ADDRESS_SWP_BITRATE, &(ps_swp_info->uicc_bitrate));
 413
 414     }
 415     return status;
 416 }
 417
 418
 419 NFCSTATUS
 420 phHciNfc_SWP_Protection(
 421                             void        *psHciHandle,
 422                             void        *pHwRef,
 423                             uint8_t     mode
 424                       )
 425 {
 426     NFCSTATUS               status = NFCSTATUS_SUCCESS;
 427     static uint8_t          param = 0 ;
 428     phHciNfc_sContext_t     *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
 429
 430     if((NULL == psHciContext)||(NULL == pHwRef))
 431     {
 432         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 433     }
 434     else if(NULL == psHciContext->p_swp_info)
 435     {
 436         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
 437     }
 438     else
 439     {
 440         phHciNfc_SWP_Info_t         *ps_swp_info=NULL;
 441         phHciNfc_Pipe_Info_t        *ps_pipe_info=NULL;
 442
 443         ps_swp_info = (phHciNfc_SWP_Info_t*)psHciContext->p_swp_info;
 444         ps_pipe_info = ps_swp_info->p_pipe_info;
 445
 446         if(NULL == ps_pipe_info)
 447         {
 448             status = PHNFCSTVAL(CID_NFC_HCI,
 449                                 NFCSTATUS_INVALID_HCI_INFORMATION);
 450         }
 451         else
 452         {
 453             ps_pipe_info->reg_index = NXP_SWP_PROTECTED_INDEX;
 454             /* Enable/Disable SWP Protection */
 455             param = (uint8_t)mode;
 456             ps_pipe_info->param_info =(void*)&param ;
 457             ps_pipe_info->param_length = sizeof(param) ;
 458             status = phHciNfc_Send_Generic_Cmd(psHciContext, pHwRef,
 459                                         ps_swp_info->pipe_id,
 460                                         (uint8_t)ANY_SET_PARAMETER);
 461         }
 462
 463     }
 464     return status;
 465 }
 466
 467
 468
 469
 470 static
 471 NFCSTATUS
 472 phHciNfc_SWP_InfoUpdate(
 473                                 phHciNfc_sContext_t     *psHciContext,
 474                                 uint8_t                 index,
 475                                 uint8_t                 *reg_value,
 476                                 uint8_t                 reg_length
 477                           )
 478 {
 479     phHciNfc_SWP_Info_t         *ps_swp_info=NULL;
 480     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
 481
 482     ps_swp_info = (phHciNfc_SWP_Info_t *)
 483                     psHciContext->p_swp_info ;
 484
 485     /* To remove "warning (VS C4100) : unreferenced formal parameter" */
 486     PHNFC_UNUSED_VARIABLE(reg_length);
 487     switch(index)
 488     {
 489         case NXP_SWP_DEFAULT_MODE_INDEX:
 490         {
 491             HCI_PRINT_BUFFER("\tUICC Enable Register:",reg_value,reg_length);
 492             break;
 493         }
 494             /* Get the Status of the UICC Connection */
 495         case NXP_SWP_STATUS_INDEX:
 496         {
 497             HCI_PRINT_BUFFER("\tUICC Connection Status:", reg_value, reg_length);
 498             ps_swp_info->uicc_status = (phHciNfc_SWP_Status_t ) *reg_value ;
 499             break;
 500         }
 501         case NXP_SWP_PROTECTED_INDEX:
 502         {
 503             HCI_PRINT_BUFFER("\t UICC Card Emulation Rights :",reg_value,reg_length);
 504
 505             break;
 506         }
 507         default:
 508         {
 509             status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
 510             break;
 511         }
 512     } /* End of switch(index) */
 513
 514     return status;
 515 }
 516
 517 NFCSTATUS
 518 phHciNfc_SWP_Configure_Mode(
 519                               void              *psHciHandle,
 520                               void              *pHwRef,
 521                               uint8_t           uicc_mode
 522                           )
 523 {
 524     NFCSTATUS               status = NFCSTATUS_SUCCESS;
 525     static uint8_t          param = 0;
 526     phHciNfc_sContext_t     *psHciContext = ((phHciNfc_sContext_t *)
 527                                             psHciHandle);
 528
 529     if( (NULL == psHciContext)||(NULL == pHwRef))
 530     {
 531       status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 532     }
 533     else if ( NULL == psHciContext->p_swp_info )
 534     {
 535         status = PHNFCSTVAL(CID_NFC_HCI,
 536                         NFCSTATUS_INVALID_HCI_INFORMATION);
 537     }
 538     else
 539     {
 540         phHciNfc_SWP_Info_t         *ps_swp_info=NULL;
 541         phHciNfc_Pipe_Info_t        *ps_pipe_info=NULL;
 542
 543         ps_swp_info = (phHciNfc_SWP_Info_t*)psHciContext->p_swp_info;
 544
 545         ps_pipe_info = ps_swp_info->p_pipe_info;
 546         if(NULL == ps_pipe_info)
 547         {
 548             status = PHNFCSTVAL(CID_NFC_HCI,
 549                                 NFCSTATUS_INVALID_HCI_INFORMATION);
 550         }
 551         else
 552         {
 553             /* Switch the Mode of the SmartMx */
 554             param = uicc_mode;
 555             ps_pipe_info->param_info =(void*)&param ;
 556             ps_pipe_info->param_length = sizeof(param) ;
 557             status = phHciNfc_Send_SWP_Event( psHciContext, pHwRef,
 558                                             ps_swp_info->pipe_id,
 559                                             NXP_EVT_SWP_SWITCH_MODE );
 560
 561             /* Send the Success Status as this is an event */
 562             status = ((status == NFCSTATUS_PENDING)?
 563                     NFCSTATUS_SUCCESS : status);
 564
 565         }/* End of else part*/
 566     }
 567     return status;
 568 }
 569
 570 static
 571 NFCSTATUS
 572 phHciNfc_Recv_SWP_Event(
 573                         void                *psContext,
 574                         void                *pHwRef,
 575                         uint8_t             *pEvent,
 576 #ifdef ONE_BYTE_LEN
 577                         uint8_t             length
 578 #else
 579                         uint16_t            length
 580 #endif
 581                        )
 582 {
 583     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
 584     phHciNfc_sContext_t         *psHciContext =
 585                                 (phHciNfc_sContext_t *)psContext ;
 586     static phHal_sEventInfo_t   EventInfo;
 587
 588
 589     if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pEvent)
 590         || (length == 0))
 591     {
 592       status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 593     }
 594     else if(NULL == psHciContext->p_swp_info)
 595     {
 596         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
 597     }
 598     else
 599     {
 600         phHciNfc_SWP_Info_t     *ps_swp_info=NULL;
 601
 602         ps_swp_info = (phHciNfc_SWP_Info_t *)
 603                         psHciContext->p_swp_info ;
 604         if( NULL == ps_swp_info->p_pipe_info)
 605         {
 606             status = PHNFCSTVAL(CID_NFC_HCI,
 607                             NFCSTATUS_INVALID_HCI_INFORMATION);
 608         }
 609         else
 610         {
 611             phHciNfc_HCP_Packet_t       *p_packet = NULL;
 612             phHciNfc_HCP_Message_t      *message = NULL;
 613             uint8_t                     EventType = 0;
 614
 615             p_packet = (phHciNfc_HCP_Packet_t *)pEvent;
 616             message = &(p_packet->msg.message);
 617             /* Get the instruction bits from the Message Header */
 618             EventType = (uint8_t) GET_BITS8( message->msg_header,
 619                 HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
 620
 621             EventInfo.eventHost = phHal_eHostController;
 622             EventInfo.eventSource = phHal_ePICC_DevType;
 623             /* Occurrence of the Protected events for reporting */
 624             if (NXP_EVT_SWP_PROTECTED == EventType)
 625             {
 626                 EventInfo.eventType = NFC_EVT_PROTECTED;
 627             }
 628             else
 629             {
 630                 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
 631             }
 632
 633             if (NFCSTATUS_SUCCESS == status )
 634             {
 635                 phHciNfc_Notify_Event(  psHciContext, pHwRef,
 636                 NFC_NOTIFY_EVENT, (void*)&EventInfo);
 637             }
 638
 639         }
 640     }
 641     return status;
 642 }
 643
 644
 645
 646 static
 647 NFCSTATUS
 648 phHciNfc_Send_SWP_Event(
 649                        phHciNfc_sContext_t      *psHciContext,
 650                        void                     *pHwRef,
 651                        uint8_t                  pipe_id,
 652                        uint8_t                  event
 653                        )
 654 {
 655     phHciNfc_HCP_Packet_t   *hcp_packet = NULL;
 656     phHciNfc_HCP_Message_t  *hcp_message = NULL;
 657     phHciNfc_Pipe_Info_t    *p_pipe_info = NULL;
 658     uint8_t                 length = 0;
 659     uint8_t                 i=0;
 660     NFCSTATUS               status = NFCSTATUS_SUCCESS;
 661
 662     p_pipe_info = (phHciNfc_Pipe_Info_t *)
 663                     psHciContext->p_pipe_list[pipe_id];
 664     psHciContext->tx_total = 0 ;
 665     length = (length + HCP_HEADER_LEN);
 666
 667     hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
 668     /* Construct the HCP Frame */
 669     phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT,
 670                             (uint8_t) pipe_id,
 671                             HCP_MSG_TYPE_EVENT, event);
 672
 673     hcp_message = &(hcp_packet->msg.message);
 674
 675     phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload,
 676                             i,
 677                             (uint8_t *)p_pipe_info->param_info,
 678                             p_pipe_info->param_length);
 679     length = (uint8_t)(length + i + p_pipe_info->param_length);
 680
 681     p_pipe_info->sent_msg_type = HCP_MSG_TYPE_EVENT ;
 682     p_pipe_info->prev_msg = event ;
 683     psHciContext->tx_total = length;
 684
 685     /* Send the Constructed HCP packet to the lower layer */
 686     status = phHciNfc_Send_HCP( psHciContext, pHwRef );
 687     if(NFCSTATUS_PENDING == status)
 688     {
 689         ((phHciNfc_SWP_Info_t *)psHciContext->p_swp_info)->current_seq =
 690             ((phHciNfc_SWP_Info_t *)psHciContext->p_swp_info)->next_seq;
 691         p_pipe_info->prev_status = status;
 692     }
 693
 694     return status;
 695 }
 696
 697 NFCSTATUS
 698 phHciNfc_SWP_Update_Sequence(
 699                                 phHciNfc_sContext_t     *psHciContext,
 700                                 phHciNfc_eSeqType_t     SWP_seq
 701                              )
 702 {
 703     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
 704     phHciNfc_SWP_Info_t         *ps_swp_info=NULL;
 705     if( NULL == psHciContext )
 706     {
 707         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 708     }
 709     else if( NULL == psHciContext->p_swp_info )
 710     {
 711         status = PHNFCSTVAL(CID_NFC_HCI,
 712                             NFCSTATUS_INVALID_HCI_INFORMATION);
 713     }
 714     else
 715     {
 716         ps_swp_info = (phHciNfc_SWP_Info_t *)
 717                             psHciContext->p_swp_info ;
 718         switch(SWP_seq)
 719         {
 720             case RESET_SEQ:
 721             case INIT_SEQ:
 722             {
 723                 ps_swp_info->current_seq = SWP_INVALID_SEQUENCE;
 724                 ps_swp_info->next_seq = SWP_INVALID_SEQUENCE ;
 725                 break;
 726             }
 727             case UPDATE_SEQ:
 728             {
 729                 ps_swp_info->current_seq = ps_swp_info->next_seq;
 730                 break;
 731             }
 732             case REL_SEQ:
 733             {
 734                 ps_swp_info->current_seq = SWP_INVALID_SEQUENCE;
 735                 ps_swp_info->next_seq =  SWP_INVALID_SEQUENCE;
 736                 break;
 737             }
 738             case CONFIG_SEQ:
 739             {
 740                 ps_swp_info->current_seq = SWP_STATUS_SEQ;
 741                 ps_swp_info->next_seq =  SWP_STATUS_SEQ;
 742                 break;
 743             }
 744             default:
 745             {
 746                 break;
 747             }
 748         }
 749     }
 750     return status;
 751 }
 752
 753 NFCSTATUS
 754 phHciNfc_SWP_Config_Sequence(
 755                             phHciNfc_sContext_t     *psHciContext,
 756                             void                    *pHwRef,
 757                             phHal_sEmulationCfg_t   *ps_emulation_cfg
 758                         )
 759 {
 760     NFCSTATUS                   status = NFCSTATUS_SUCCESS;
 761     phHciNfc_SWP_Info_t         *ps_swp_info=NULL;
 762
 763     if ((NULL == psHciContext) || (NULL == pHwRef) ||
 764         (NULL == ps_emulation_cfg))
 765     {
 766         status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
 767     }
 768     else if( NULL == psHciContext->p_swp_info )
 769     {
 770         status = PHNFCSTVAL(CID_NFC_HCI,
 771                             NFCSTATUS_INVALID_HCI_INFORMATION);
 772     }
 773     else
 774     {
 775         phHciNfc_Pipe_Info_t        *ps_pipe_info = NULL;
 776         phHal_sUiccEmuCfg_t         *uicc_config =
 777                                     &(ps_emulation_cfg->config.uiccEmuCfg);
 778
 779         ps_swp_info = (phHciNfc_SWP_Info_t *)psHciContext->p_swp_info;
 780         ps_pipe_info = ps_swp_info->p_pipe_info;
 781
 782         if (NULL == ps_pipe_info)
 783         {
 784             status = PHNFCSTVAL(CID_NFC_HCI,
 785                                 NFCSTATUS_INVALID_HCI_INFORMATION);
 786         }
 787         else
 788         {
 789             switch(ps_swp_info->current_seq)
 790             {
 791                 case SWP_STATUS_SEQ :
 792                 {
 793                     status = phHciNfc_SWP_Configure_Default( psHciContext,
 794                                             pHwRef, uicc_config->enableUicc );
 795
 796                     if(status == NFCSTATUS_PENDING)
 797                     {
 798                         ps_swp_info->next_seq = SWP_STATUS_SEQ;
 799                         status = NFCSTATUS_SUCCESS;
 800                     }
 801                     break;
 802                 }
 803                 case SWP_MODE_SEQ :
 804                 {
 805                     status = phHciNfc_SWP_Configure_Mode( psHciContext,
 806                                         pHwRef, UICC_SWITCH_MODE_DEFAULT );
 807                                         /* UICC_SWITCH_MODE_ON  */
 808                     if(status == NFCSTATUS_PENDING)
 809                     {
 810                         ps_swp_info->next_seq = SWP_STATUS_SEQ;
 811                         status = NFCSTATUS_SUCCESS;
 812                     }
 813                     break;
 814                 }
 815                 default :
 816                 {
 817                     status = PHNFCSTVAL(CID_NFC_HCI,
 818                                         NFCSTATUS_INVALID_HCI_INFORMATION);
 819                     break;
 820                 }
 821             }
 822         }
 823     }
 824     return status;
 825 }
 826
 827
 828