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
66static
67NFCSTATUS
68phHciNfc_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
79static
80NFCSTATUS
81phHciNfc_Send_SWP_Event(
82                       phHciNfc_sContext_t      *psHciContext,
83                       void                     *pHwRef,
84                       uint8_t                  pipe_id,
85                       uint8_t                  event
86                       );
87
88
89static
90NFCSTATUS
91phHciNfc_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
102static
103NFCSTATUS
104phHciNfc_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
115NFCSTATUS
116phHciNfc_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
140NFCSTATUS
141phHciNfc_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
171NFCSTATUS
172phHciNfc_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
207static
208NFCSTATUS
209phHciNfc_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
295NFCSTATUS
296phHciNfc_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
344NFCSTATUS
345phHciNfc_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
387NFCSTATUS
388phHciNfc_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
419NFCSTATUS
420phHciNfc_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
470static
471NFCSTATUS
472phHciNfc_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
517NFCSTATUS
518phHciNfc_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
570static
571NFCSTATUS
572phHciNfc_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
646static
647NFCSTATUS
648phHciNfc_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
697NFCSTATUS
698phHciNfc_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
753NFCSTATUS
754phHciNfc_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
829