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_IDMgmt.c                                                    *
22* \brief HCI Identity Management Gate Routines.                               *
23*                                                                             *
24*                                                                             *
25* Project: NFC-FRI-1.1                                                        *
26*                                                                             *
27* $Date: Fri Jun 11 11:19:25 2010 $                                           *
28* $Author: ing04880 $                                                         *
29* $Revision: 1.23 $                                                            *
30* $Aliases: NFC_FRI1.1_WK1023_R35_1 $
31*                                                                             *
32* =========================================================================== *
33*/
34
35/*
36***************************** Header File Inclusion ****************************
37*/
38#include <phNfcCompId.h>
39#include <phHciNfc_Pipe.h>
40#include <phHciNfc_IDMgmt.h>
41#include <phOsalNfc.h>
42
43/*
44****************************** Macro Definitions *******************************
45*/
46
47#define FW_VERSION_INDEX        0x01U
48#define HCI_VERSION_INDEX       0x02U
49#define HW_VERSION_INDEX        0x03U
50#define VENDOR_NAME_INDEX       0x04U
51#define MODEL_ID_INDEX          0x05U
52#define GATES_LIST_INDEX        0x06U
53#define FULL_VERSION_INDEX      0x10U
54
55#define VERSION_LEN             0x03U
56#define GATES_LIST_LEN          0x20U
57
58/*
59*************************** Structure and Enumeration ***************************
60*/
61
62
63/** \defgroup grp_hci_nfc HCI Identity Management Component
64 *
65 *
66 */
67
68typedef enum phHciNfc_IDMgmt_Seq{
69    IDMGMT_PIPE_OPEN        = 0x00U,
70    IDMGMT_GET_FULL_VERSION,
71    IDMGMT_GET_FW_VERSION,
72    IDMGMT_GET_HW_VERSION,
73    IDMGMT_GET_HCI_VERSION,
74    IDMGMT_GET_VENDOR_NAME,
75    IDMGMT_GET_MODEL_ID,
76    IDMGMT_GET_GATES_LIST,
77    IDMGMT_PIPE_CLOSE
78} phHciNfc_IDMgmt_Seq_t;
79
80typedef struct phHciNfc_IDMgmt_Info{
81    phHciNfc_IDMgmt_Seq_t   id_cur_seq;
82    phHciNfc_IDMgmt_Seq_t   id_next_seq;
83    phHciNfc_Pipe_Info_t    *p_pipe_info;
84    uint8_t                 pipe_id;
85    uint32_t                fw_version;
86    uint32_t                hw_version;
87    utf8_t                  vendor_name[VENDOR_NAME_LEN];
88    uint8_t                 model_id;
89    uint8_t                 hci_version;
90    uint8_t                 gates_list[GATES_LIST_LEN];
91    uint8_t                 full_version[NXP_FULL_VERSION_LEN];
92} phHciNfc_IDMgmt_Info_t;
93
94/*
95*************************** Static Function Declaration **************************
96*/
97
98static
99NFCSTATUS
100phHciNfc_IDMgmt_InfoUpdate(
101                                phHciNfc_sContext_t     *psHciContext,
102                                phHal_sHwReference_t    *pHwRef,
103                                uint8_t                 index,
104                                uint8_t                 *reg_value,
105                                uint8_t                 reg_length
106                         );
107
108static
109NFCSTATUS
110phHciNfc_Recv_IDMgmt_Response(
111                        void                *psHciContext,
112                        void                *pHwRef,
113                        uint8_t             *pResponse,
114#ifdef ONE_BYTE_LEN
115                        uint8_t             length
116#else
117                        uint16_t            length
118#endif
119                       );
120
121
122/*
123*************************** Function Definitions ***************************
124*/
125
126/*!
127 * \brief Allocates the resources of Identity Managment Gate.
128 *
129 * This function Allocates the resources of the Identity Management
130 * gate Information Structure.
131 *
132 */
133
134NFCSTATUS
135phHciNfc_IDMgmt_Init_Resources(
136                                phHciNfc_sContext_t     *psHciContext
137                             )
138{
139    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
140    phHciNfc_IDMgmt_Info_t      *p_identity_info=NULL;
141    if( NULL == psHciContext )
142    {
143        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
144    }
145    else
146    {
147        if( ( NULL == psHciContext->p_identity_info )
148            && (phHciNfc_Allocate_Resource((void **)(&p_identity_info),
149                    sizeof(phHciNfc_IDMgmt_Info_t))== NFCSTATUS_SUCCESS)
150        )
151        {
152            psHciContext->p_identity_info = p_identity_info;
153            p_identity_info->id_cur_seq = IDMGMT_PIPE_OPEN;
154            p_identity_info->id_next_seq = IDMGMT_PIPE_OPEN;
155            p_identity_info->pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
156        }
157        else
158        {
159            status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
160        }
161    }
162    return status;
163}
164
165/*!
166 * \brief Get the pipe_id of Identity Managment Gate.
167 *
168 * This function Get the pipe_id of Identity Managment Gate.
169 *
170 */
171
172
173NFCSTATUS
174phHciNfc_IDMgmt_Get_PipeID(
175                                phHciNfc_sContext_t     *psHciContext,
176                                uint8_t                 *ppipe_id
177                             )
178{
179    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
180    phHciNfc_IDMgmt_Info_t      *p_identity_info=NULL;
181    if( (NULL != psHciContext)
182        && ( NULL != ppipe_id )
183        && ( NULL != psHciContext->p_identity_info )
184      )
185    {
186        p_identity_info = (phHciNfc_IDMgmt_Info_t *)
187                            psHciContext->p_identity_info ;
188        *ppipe_id =  p_identity_info->pipe_id  ;
189    }
190    else
191    {
192        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
193    }
194    return status;
195}
196
197NFCSTATUS
198phHciNfc_IDMgmt_Update_Sequence(
199                                phHciNfc_sContext_t     *psHciContext,
200                                phHciNfc_eSeqType_t     reader_seq
201                             )
202{
203    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
204    phHciNfc_IDMgmt_Info_t      *p_identity_info=NULL;
205    if( NULL == psHciContext )
206    {
207        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
208    }
209    else
210    {
211        if( NULL == psHciContext->p_identity_info )
212        {
213            status = PHNFCSTVAL(CID_NFC_HCI,
214                        NFCSTATUS_INVALID_HCI_INFORMATION);
215        }
216        else
217        {
218            p_identity_info = (phHciNfc_IDMgmt_Info_t *)
219                                psHciContext->p_identity_info ;
220            switch(reader_seq)
221            {
222                case RESET_SEQ:
223                case INIT_SEQ:
224                {
225                    p_identity_info->id_cur_seq = IDMGMT_PIPE_OPEN;
226                    p_identity_info->id_next_seq = IDMGMT_PIPE_OPEN;
227                    break;
228                }
229                case UPDATE_SEQ:
230                {
231                    p_identity_info->id_cur_seq =
232                                            p_identity_info->id_next_seq;
233                    break;
234                }
235                case INFO_SEQ:
236                {
237                    p_identity_info->id_cur_seq = IDMGMT_GET_FW_VERSION;
238                    p_identity_info->id_next_seq = IDMGMT_GET_FW_VERSION;
239                    break;
240                }
241                case REL_SEQ:
242                {
243                    p_identity_info->id_cur_seq = IDMGMT_PIPE_CLOSE;
244                    p_identity_info->id_next_seq = IDMGMT_PIPE_CLOSE;
245                    break;
246                }
247                default:
248                {
249                    break;
250                }
251            }
252        }
253    }
254
255    return status;
256
257}
258
259
260
261/*!
262 * \brief Initialisation of Identity Managment Gate.
263 *
264 * This function initialses the Identity Management gate and
265 * populates the Identity Management Information Structure
266 *
267 */
268
269NFCSTATUS
270phHciNfc_IDMgmt_Initialise(
271                                phHciNfc_sContext_t     *psHciContext,
272                                void                    *pHwRef
273                         )
274{
275    NFCSTATUS                           status = NFCSTATUS_SUCCESS;
276    phHciNfc_Pipe_Info_t                *p_pipe_info = NULL;
277    phHciNfc_IDMgmt_Info_t              *p_identity_info=NULL;
278#ifndef ESTABLISH_SESSION
279    uint8_t                             id_pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
280#endif
281
282    if( NULL == psHciContext )
283    {
284        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
285    }
286    else
287    {
288
289        if( NULL == psHciContext->p_identity_info )
290        {
291            status = PHNFCSTVAL(CID_NFC_HCI,
292                        NFCSTATUS_INVALID_HCI_INFORMATION);
293        }
294        else
295        {
296            p_identity_info = (phHciNfc_IDMgmt_Info_t *)
297                                psHciContext->p_identity_info ;
298            p_pipe_info = p_identity_info->p_pipe_info;
299            if(NULL == p_pipe_info )
300            {
301                status = PHNFCSTVAL(CID_NFC_HCI,
302                                NFCSTATUS_NOT_ALLOWED);
303            }
304            else
305            {
306                switch(p_identity_info->id_cur_seq )
307                {
308                    /* Identity Mgmt pipe open sequence */
309                    case IDMGMT_PIPE_OPEN:
310                    {
311                        status = phHciNfc_Open_Pipe( psHciContext,
312                                                        pHwRef, p_pipe_info );
313                        if(status == NFCSTATUS_SUCCESS)
314                        {
315                            p_identity_info->id_next_seq = IDMGMT_GET_FW_VERSION;
316#ifndef ESTABLISH_SESSION
317                            status = NFCSTATUS_PENDING;
318#endif
319                        }
320                        break;
321                    }
322#ifndef ESTABLISH_SESSION
323                    case IDMGMT_GET_FW_VERSION:
324                    {
325                        p_pipe_info->reg_index = FW_VERSION_INDEX;
326                        id_pipe_id = p_identity_info->pipe_id ;
327                        status =
328                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
329                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
330                        if(NFCSTATUS_PENDING == status )
331                        {
332                            p_identity_info->id_next_seq = IDMGMT_GET_HW_VERSION;
333                            /* status = NFCSTATUS_SUCCESS; */
334                        }
335                        break;
336                    }
337                    case IDMGMT_GET_HW_VERSION:
338                    {
339                        p_pipe_info->reg_index = HW_VERSION_INDEX;
340                        id_pipe_id = p_identity_info->pipe_id ;
341                        status =
342                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
343                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
344                        if(NFCSTATUS_PENDING == status )
345                        {
346                            p_identity_info->id_next_seq = IDMGMT_GET_HCI_VERSION;
347                            /* status = NFCSTATUS_SUCCESS; */
348                        }
349                        break;
350                    }
351                    case IDMGMT_GET_HCI_VERSION:
352                    {
353                        p_pipe_info->reg_index = HCI_VERSION_INDEX;
354                        id_pipe_id = p_identity_info->pipe_id ;
355                        status =
356                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
357                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
358                        if(NFCSTATUS_PENDING == status )
359                        {
360                            p_identity_info->id_next_seq = IDMGMT_GET_VENDOR_NAME;
361                            /* status = NFCSTATUS_SUCCESS; */
362                        }
363                        break;
364                    }
365                    case IDMGMT_GET_VENDOR_NAME:
366                    {
367                        p_pipe_info->reg_index = VENDOR_NAME_INDEX;
368                        id_pipe_id = p_identity_info->pipe_id ;
369                        status =
370                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
371                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
372                        if(NFCSTATUS_PENDING == status )
373                        {
374                            p_identity_info->id_next_seq = IDMGMT_GET_MODEL_ID;
375                            /* status = NFCSTATUS_SUCCESS; */
376                        }
377                        break;
378                    }
379                    case IDMGMT_GET_MODEL_ID:
380                    {
381                        p_pipe_info->reg_index = MODEL_ID_INDEX;
382                        id_pipe_id = p_identity_info->pipe_id ;
383                        status =
384                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
385                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
386                        if(NFCSTATUS_PENDING == status )
387                        {
388                            p_identity_info->id_next_seq = IDMGMT_GET_GATES_LIST;
389                            /* status = NFCSTATUS_SUCCESS; */
390                        }
391                        break;
392                    }
393                    case IDMGMT_GET_GATES_LIST:
394                    {
395                        p_pipe_info->reg_index = GATES_LIST_INDEX;
396                        id_pipe_id = p_identity_info->pipe_id ;
397                        status =
398                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
399                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
400                        if(NFCSTATUS_PENDING == status )
401                        {
402                            p_identity_info->id_next_seq = IDMGMT_GET_FULL_VERSION;
403                            /* status = NFCSTATUS_SUCCESS; */
404                        }
405                        break;
406                    }
407                    case IDMGMT_GET_FULL_VERSION:
408                    {
409                        p_pipe_info->reg_index = FULL_VERSION_INDEX;
410                        id_pipe_id = p_identity_info->pipe_id ;
411                        status =
412                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
413                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
414                        if(NFCSTATUS_PENDING == status )
415                        {
416                            p_identity_info->id_next_seq = IDMGMT_PIPE_CLOSE;
417                            status = NFCSTATUS_SUCCESS;
418                        }
419                        break;
420                    }
421#endif
422                    default:
423                    {
424                        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE);
425                        break;
426                    }
427
428                }/* End of the Sequence Switch */
429            }/* End of Pipe Info Memory Check */
430
431        }/* End of the Identity Info Memory Check */
432
433    } /* End of Null Context Check */
434
435    return status;
436}
437
438
439
440/*!
441 * \brief Initialisation of Identity Managment Gate.
442 *
443 * This function initialses the Identity Management gate and
444 * populates the Identity Management Information Structure
445 *
446 */
447
448NFCSTATUS
449phHciNfc_IDMgmt_Info_Sequence(
450                                phHciNfc_sContext_t     *psHciContext,
451                                void                    *pHwRef
452                         )
453{
454    NFCSTATUS                           status = NFCSTATUS_SUCCESS;
455    phHciNfc_Pipe_Info_t                *p_pipe_info = NULL;
456    phHciNfc_IDMgmt_Info_t              *p_identity_info=NULL;
457    uint8_t                             id_pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
458
459    if( NULL == psHciContext )
460    {
461        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
462    }
463    else
464    {
465
466        if( NULL == psHciContext->p_identity_info )
467        {
468            status = PHNFCSTVAL(CID_NFC_HCI,
469                        NFCSTATUS_INVALID_HCI_INFORMATION);
470        }
471        else
472        {
473            p_identity_info = (phHciNfc_IDMgmt_Info_t *)
474                                psHciContext->p_identity_info ;
475            p_pipe_info = p_identity_info->p_pipe_info;
476            if(NULL == p_pipe_info )
477            {
478                status = PHNFCSTVAL(CID_NFC_HCI,
479                                NFCSTATUS_NOT_ALLOWED);
480            }
481            else
482            {
483                switch(p_identity_info->id_cur_seq )
484                {
485                    case IDMGMT_GET_FW_VERSION:
486                    {
487                        p_pipe_info->reg_index = FW_VERSION_INDEX;
488                        id_pipe_id = p_identity_info->pipe_id ;
489                        status =
490                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
491                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
492                        if(NFCSTATUS_PENDING == status )
493                        {
494                            p_identity_info->id_next_seq = IDMGMT_GET_HW_VERSION;
495                            /* status = NFCSTATUS_SUCCESS; */
496                        }
497                        break;
498                    }
499                    case IDMGMT_GET_HW_VERSION:
500                    {
501                        p_pipe_info->reg_index = HW_VERSION_INDEX;
502                        id_pipe_id = p_identity_info->pipe_id ;
503                        status =
504                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
505                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
506                        if(NFCSTATUS_PENDING == status )
507                        {
508                            p_identity_info->id_next_seq = IDMGMT_GET_HCI_VERSION;
509                            /* status = NFCSTATUS_SUCCESS; */
510                        }
511                        break;
512                    }
513                    case IDMGMT_GET_HCI_VERSION:
514                    {
515                        p_pipe_info->reg_index = HCI_VERSION_INDEX;
516                        id_pipe_id = p_identity_info->pipe_id ;
517                        status =
518                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
519                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
520                        if(NFCSTATUS_PENDING == status )
521                        {
522                            p_identity_info->id_next_seq = IDMGMT_GET_VENDOR_NAME;
523                            /* status = NFCSTATUS_SUCCESS; */
524                        }
525                        break;
526                    }
527                    case IDMGMT_GET_VENDOR_NAME:
528                    {
529                        p_pipe_info->reg_index = VENDOR_NAME_INDEX;
530                        id_pipe_id = p_identity_info->pipe_id ;
531                        status =
532                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
533                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
534                        if(NFCSTATUS_PENDING == status )
535                        {
536                            p_identity_info->id_next_seq = IDMGMT_GET_MODEL_ID;
537                            /* status = NFCSTATUS_SUCCESS; */
538                        }
539                        break;
540                    }
541                    case IDMGMT_GET_MODEL_ID:
542                    {
543                        p_pipe_info->reg_index = MODEL_ID_INDEX;
544                        id_pipe_id = p_identity_info->pipe_id ;
545                        status =
546                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
547                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
548                        if(NFCSTATUS_PENDING == status )
549                        {
550                            p_identity_info->id_next_seq = IDMGMT_GET_GATES_LIST;
551                            /* status = NFCSTATUS_SUCCESS; */
552                        }
553                        break;
554                    }
555                    case IDMGMT_GET_GATES_LIST:
556                    {
557                        p_pipe_info->reg_index = GATES_LIST_INDEX;
558                        id_pipe_id = p_identity_info->pipe_id ;
559                        status =
560                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
561                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
562                        if(NFCSTATUS_PENDING == status )
563                        {
564                            p_identity_info->id_next_seq = IDMGMT_GET_FULL_VERSION;
565                            /* status = NFCSTATUS_SUCCESS; */
566                        }
567                        break;
568                    }
569                    case IDMGMT_GET_FULL_VERSION:
570                    {
571                        p_pipe_info->reg_index = FULL_VERSION_INDEX;
572                        id_pipe_id = p_identity_info->pipe_id ;
573                        status =
574                            phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
575                                id_pipe_id, (uint8_t)ANY_GET_PARAMETER );
576                        if(NFCSTATUS_PENDING == status )
577                        {
578                            p_identity_info->id_next_seq = IDMGMT_PIPE_CLOSE;
579                            status = NFCSTATUS_SUCCESS;
580                        }
581                        break;
582                    }
583                    default:
584                    {
585                        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE);
586                        break;
587                    }
588
589                }/* End of the Sequence Switch */
590            }/* End of Pipe Info Memory Check */
591
592        }/* End of the Identity Info Memory Check */
593
594    } /* End of Null Context Check */
595
596    return status;
597}
598
599/*!
600 * \brief Releases the resources allocated the Identity Management.
601 *
602 * This function Releases the resources allocated the Identity Management.
603 */
604
605NFCSTATUS
606phHciNfc_IDMgmt_Release(
607                                phHciNfc_sContext_t     *psHciContext,
608                                void                    *pHwRef
609                             )
610{
611    NFCSTATUS                           status = NFCSTATUS_SUCCESS;
612    phHciNfc_Pipe_Info_t                *p_pipe_info = NULL;
613    phHciNfc_IDMgmt_Info_t              *p_identity_info=NULL;
614    /* static phHciNfc_IDMgmt_Seq_t     identity_init_seq = IDMGMT_PIPE_CREATE; */
615
616    if( (NULL == psHciContext) || (NULL == pHwRef) )
617    {
618      status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
619    }
620    else
621    {
622        if( NULL != psHciContext->p_identity_info )
623        {
624            p_identity_info = (phHciNfc_IDMgmt_Info_t *)
625                                psHciContext->p_identity_info ;
626            p_pipe_info = p_identity_info->p_pipe_info;
627
628            status = phHciNfc_Close_Pipe( psHciContext,
629                                                pHwRef, p_pipe_info );
630        }
631        else
632        {
633            status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_NOT_ALLOWED);
634
635        }/* End of the Identity Info Memory Check */
636
637    } /* End of Null Context Check */
638
639    return status;
640}
641
642
643/*!
644 * \brief Receives the HCI Response from the corresponding peripheral device.
645 *
646 * This function receives the HCI Command Response from the connected NFC
647 * Pheripheral device.
648 */
649static
650NFCSTATUS
651phHciNfc_Recv_IDMgmt_Response(
652                        void                *psContext,
653                        void                *pHwRef,
654                        uint8_t             *pResponse,
655#ifdef ONE_BYTE_LEN
656                        uint8_t             length
657#else
658                        uint16_t            length
659#endif
660                    )
661{
662    phHciNfc_sContext_t         *psHciContext =
663                                    (phHciNfc_sContext_t *)psContext ;
664    phHciNfc_IDMgmt_Info_t      *p_identity_info=NULL;
665    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
666    uint8_t                     prev_cmd = ANY_GET_PARAMETER;
667
668    if( (NULL == psHciContext) || (NULL == pHwRef) )
669    {
670      status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
671    }
672    else if(  NULL == psHciContext->p_identity_info )
673    {
674        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
675    }
676    else
677    {
678        p_identity_info = (phHciNfc_IDMgmt_Info_t *)
679                            psHciContext->p_identity_info ;
680        if( NULL != p_identity_info->p_pipe_info)
681        {
682            prev_cmd = p_identity_info->p_pipe_info->prev_msg ;
683            switch(prev_cmd)
684            {
685                case ANY_GET_PARAMETER:
686                {
687                    status = phHciNfc_IDMgmt_InfoUpdate(psHciContext,
688                                (phHal_sHwReference_t *)pHwRef,
689                                p_identity_info->p_pipe_info->reg_index,
690                                &pResponse[HCP_HEADER_LEN],
691                                    (uint8_t)(length - HCP_HEADER_LEN));
692                    break;
693                }
694                case ANY_SET_PARAMETER:
695                {
696                    status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
697                    break;
698                }
699                case ANY_OPEN_PIPE:
700                {
701                    break;
702                }
703                case ANY_CLOSE_PIPE:
704                {
705                    break;
706                }
707                default:
708                {
709                    status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
710                    break;
711                }
712            }
713            if( NFCSTATUS_SUCCESS == status )
714            {
715                p_identity_info->p_pipe_info->prev_status = NFCSTATUS_SUCCESS;
716                p_identity_info->id_cur_seq = p_identity_info->id_next_seq;
717            }
718        }
719    }
720    return status;
721}
722
723/* Function to Update the  Pipe Information */
724NFCSTATUS
725phHciNfc_IDMgmt_Update_PipeInfo(
726                                phHciNfc_sContext_t     *psHciContext,
727                                uint8_t                 pipe_id,
728                                phHciNfc_Pipe_Info_t    *pPipeInfo
729                        )
730{
731    phHciNfc_IDMgmt_Info_t      *p_identity_info=NULL;
732    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
733
734    if( NULL == psHciContext )
735    {
736        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
737    }
738    else if ( NULL == psHciContext->p_identity_info )
739    {
740        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
741    }
742    else
743    {
744        p_identity_info = (phHciNfc_IDMgmt_Info_t *)
745                                psHciContext->p_identity_info ;
746        /* Update the pipe_id of the ID Mgmt Gate obtained from the HCI Response */
747        p_identity_info->pipe_id = pipe_id;
748        p_identity_info->p_pipe_info = pPipeInfo;
749        if ( NULL != pPipeInfo)
750        {
751            /* Update the Response Receive routine of the IDMgmt Gate */
752            pPipeInfo->recv_resp = &phHciNfc_Recv_IDMgmt_Response;
753        }
754    }
755
756    return status;
757}
758
759static
760NFCSTATUS
761phHciNfc_IDMgmt_InfoUpdate(
762                                phHciNfc_sContext_t     *psHciContext,
763                                phHal_sHwReference_t    *pHwRef,
764                                uint8_t                 index,
765                                uint8_t                 *reg_value,
766                                uint8_t                 reg_length
767                          )
768{
769    phHciNfc_IDMgmt_Info_t      *p_identity_info=NULL;
770    NFCSTATUS                   status = NFCSTATUS_SUCCESS;
771    uint8_t                     i=0;
772    if( (NULL == psHciContext)
773        || (NULL == reg_value)
774        || (reg_length == 0)
775      )
776    {
777        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
778    }
779    else if ( NULL == psHciContext->p_identity_info )
780    {
781        status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
782    }
783    else
784    {
785        p_identity_info = (phHciNfc_IDMgmt_Info_t *)
786                                psHciContext->p_identity_info ;
787
788        switch(index)
789        {
790            case FW_VERSION_INDEX :
791            {
792                HCI_PRINT_BUFFER("\tFW Version:",reg_value,reg_length);
793                for(i=0 ;(reg_length == VERSION_LEN)&&(i < reg_length); i++)
794                {
795                    p_identity_info->fw_version |=
796                                (uint32_t)(reg_value[VERSION_LEN - i - 1] << (BYTE_SIZE * i));
797                }
798                pHwRef->device_info.fw_version = p_identity_info->fw_version ;
799                break;
800            }
801            case HW_VERSION_INDEX :
802            {
803                HCI_PRINT_BUFFER("\tHW Version:",reg_value,reg_length);
804                for(i=0 ;(reg_length == VERSION_LEN)&&(i < reg_length); i++)
805                {
806                    p_identity_info->hw_version |=
807                                (uint32_t)(reg_value[VERSION_LEN - i - 1] << (BYTE_SIZE * i));
808                }
809                pHwRef->device_info.hw_version = p_identity_info->hw_version ;
810                break;
811            }
812            case VENDOR_NAME_INDEX :
813            {
814                for(i=0 ;(reg_length <= VENDOR_NAME_LEN)&&(i < reg_length); i++)
815                {
816                    p_identity_info->vendor_name[i] = reg_value[i];
817                    pHwRef->device_info.vendor_name[i]= reg_value[i];
818                }
819                HCI_DEBUG("\tVendor Name:%s",p_identity_info->vendor_name);
820                break;
821            }
822            case MODEL_ID_INDEX :
823            {
824                HCI_PRINT_BUFFER("\tModel ID:",reg_value,reg_length);
825                p_identity_info->model_id = reg_value[i] ;
826                pHwRef->device_info.model_id = p_identity_info->model_id  ;
827#ifndef NXP_HAL_ENABLE_SMX
828                if( NFC_HW_PN65N == pHwRef->device_info.model_id)
829#endif
830                {
831                  pHwRef->smx_connected = TRUE;
832                }
833                break;
834            }
835            case HCI_VERSION_INDEX :
836            {
837                HCI_PRINT_BUFFER("\tHCI Version:",reg_value,reg_length);
838                p_identity_info->hci_version = reg_value[i] ;
839                pHwRef->device_info.hci_version = p_identity_info->hci_version  ;
840                break;
841            }
842            case GATES_LIST_INDEX :
843            {
844                HCI_PRINT_BUFFER("\tGates List:",reg_value,reg_length);
845                for(i=0 ;(reg_length <= GATES_LIST_LEN)&&(i < reg_length); i++)
846                {
847                    p_identity_info->gates_list[i] = reg_value[i];
848                }
849                break;
850            }
851            case FULL_VERSION_INDEX :
852            {
853                HCI_PRINT_BUFFER("\tVERSION INFO:",reg_value,reg_length);
854                for(i=0 ;(reg_length <= NXP_FULL_VERSION_LEN)&&(i < reg_length); i++)
855                {
856                    p_identity_info->full_version[i] = reg_value[i];
857                    pHwRef->device_info.full_version[i]= reg_value[i];
858                }
859                break;
860            }
861            default:
862            {
863                status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
864                break;
865            } /*End of the default Switch Case */
866
867        } /*End of the Index Switch */
868
869    } /* End of Context and the Identity information validity check */
870
871    return status;
872}
873