Gitiles
Code Review Sign In
review.blissroms.org / platform_external_libnfc-nxp / refs/heads/o8.0-rebase / . / src / phHciNfc_RFReader.c
blob: 919f3fd7157a02efbcd31e2f80f75d683db4cba0 [file] [log] [blame]
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]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_RFReader.c *
22* \brief HCI RF Reader Management Gate Routines. *
23* *
24* *
25* Project: NFC-FRI-1.1 *
26* *
27* $Date: Wed Apr 21 12:21:15 2010 $ *
28* $Author: ing07385 $ *
29* $Revision: 1.53 $ *
aferire1b8bff2010-11-02 22:57:43 -0500[diff] [blame]30* $Aliases: NFC_FRI1.1_WK1007_R33_6 $ *
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]31* *
32* =========================================================================== *
33*/
34
35/*
36***************************** Header File Inclusion ****************************
37*/
38#include <phNfcConfig.h>
39#include <phNfcCompId.h>
40#include <phHciNfc_Pipe.h>
41#include <phHciNfc_RFReader.h>
42#include <phHciNfc_RFReaderA.h>
43#ifdef TYPE_B
44#include <phHciNfc_RFReaderB.h>
45#endif
46#ifdef ENABLE_P2P
47#include <phHciNfc_NfcIPMgmt.h>
48#endif
49#ifdef TYPE_FELICA
50#include <phHciNfc_Felica.h>
51#endif
52#ifdef TYPE_JEWEL
53#include <phHciNfc_Jewel.h>
54#endif
55#ifdef TYPE_ISO15693
56#include <phHciNfc_ISO15693.h>
57#endif /* #ifdef TYPE_ISO15693 */
58#include <phOsalNfc.h>
59
60/*
61****************************** Macro Definitions *******************************
62*/
63
64#define NFCIP_ACTIVATE_DELAY 0x05U
65
Martijn Coenen72854a22011-01-12 20:44:37 +0100[diff] [blame]66uint8_t nxp_nfc_isoxchg_timeout = NXP_ISO_XCHG_TIMEOUT;
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]67/*
68*************************** Structure and Enumeration ***************************
69*/
70
71
72/** \defgroup grp_hci_nfc HCI Reader RF Management Component
73 *
74 *
75 */
76
77
78typedef enum phHciNfc_ReaderMgmt_Seq{
79 READERA_PIPE_OPEN = 0x00U,
80 READERB_PIPE_OPEN,
81 FELICA_PROP_PIPE_OPEN,
82 JEWEL_PROP_PIPE_OPEN,
83 ISO15693_PROP_PIPE_OPEN,
84 NFCIP1_INITIATOR_PIPE_OPEN,
85 NFCIP1_INITIATOR_MODE_CONFIG,
86 NFCIP1_INITIATOR_PSL1_CONFIG,
87 NFCIP1_INITIATOR_PSL2_CONFIG,
88 READERA_DISABLE_AUTO_ACTIVATE,
89
90
91 READERA_PIPE_CLOSE,
92 READERB_PIPE_CLOSE,
93 FELICA_PROP_PIPE_CLOSE,
94 JEWEL_PROP_PIPE_CLOSE,
95 ISO15693_PROP_PIPE_CLOSE,
96 NFCIP1_INITIATOR_PIPE_CLOSE,
97 END_READER_SEQUENCE
98} phHciNfc_ReaderMgmt_Seq_t;
99
100typedef struct phHciNfc_ReaderMgmt_Info{
101 phHciNfc_ReaderMgmt_Seq_t rf_gate_cur_seq;
102 phHciNfc_ReaderMgmt_Seq_t rf_gate_next_seq;
103} phHciNfc_ReaderMgmt_Info_t;
104
105
106/*
107*************************** Static Function Declaration **************************
108*/
109static
110NFCSTATUS
111phHciNfc_ReaderMgmt_End_Discovery(
112 phHciNfc_sContext_t *psHciContext,
113 void *pHwRef,
114 uint8_t reader_pipe_id
115 );
116
117static
118NFCSTATUS
119phHciNfc_ReaderMgmt_Initiate_Discovery(
120 phHciNfc_sContext_t *psHciContext,
121 void *pHwRef,
122 uint8_t reader_pipe_id
123 );
124
125/*
126*************************** Function Definitions ***************************
127*/
128
129#ifdef READER_INIT
130/*!
131 * \brief Allocates the resources of RF Reader Managment Gate.
132 *
133 * This function Allocates the resources of the RF Reader Management
134 * gate Information Structure.
135 *
136 */
137
138NFCSTATUS
139phHciNfc_ReaderMgmt_Init_Resources(
140 phHciNfc_sContext_t *psHciContext
141 )
142{
143 NFCSTATUS status = NFCSTATUS_SUCCESS;
144 phHciNfc_ReaderMgmt_Info_t *p_reader_mgmt_info=NULL;
145 if( NULL == psHciContext )
146 {
147 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
148 }
149 else
150 {
151 if( ( NULL == psHciContext->p_reader_mgmt_info )
152 && (phHciNfc_Allocate_Resource((void **)(&p_reader_mgmt_info),
153 sizeof(phHciNfc_ReaderMgmt_Info_t))== NFCSTATUS_SUCCESS)
154 )
155 {
156 psHciContext->p_reader_mgmt_info = p_reader_mgmt_info;
157 p_reader_mgmt_info->rf_gate_cur_seq = READERA_PIPE_OPEN;
158 p_reader_mgmt_info->rf_gate_next_seq = END_READER_SEQUENCE;
159 }
160 else
161 {
162 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
163 }
164 }
165 return status;
166}
167
168#endif
169
170/*!
171 * \brief Updates the Sequence of RF Reader Managment Gate.
172 *
173 * This function Resets/Updates the sequence of the RF Reader Management
174 * gate.
175 *
176 */
177
178NFCSTATUS
179phHciNfc_ReaderMgmt_Update_Sequence(
180 phHciNfc_sContext_t *psHciContext,
181 phHciNfc_eSeqType_t reader_seq
182 )
183{
184 NFCSTATUS status = NFCSTATUS_SUCCESS;
185 phHciNfc_ReaderMgmt_Info_t *p_reader_mgmt_info = NULL;
186 if( NULL == psHciContext )
187 {
188 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
189 }
190 else
191 {
192 if( NULL == psHciContext->p_reader_mgmt_info )
193 {
194 status = PHNFCSTVAL(CID_NFC_HCI,
195 NFCSTATUS_INVALID_HCI_INFORMATION);
196 }
197 else
198 {
199 p_reader_mgmt_info = (phHciNfc_ReaderMgmt_Info_t *)
200 psHciContext->p_reader_mgmt_info ;
201 switch(reader_seq)
202 {
203 case RESET_SEQ:
204 case INIT_SEQ:
205 {
206 p_reader_mgmt_info->rf_gate_cur_seq = READERA_PIPE_OPEN;
207 p_reader_mgmt_info->rf_gate_next_seq = END_READER_SEQUENCE;
208 break;
209 }
210 case UPDATE_SEQ:
211 {
212 p_reader_mgmt_info->rf_gate_cur_seq =
213 p_reader_mgmt_info->rf_gate_next_seq;
214 break;
215 }
216 case INFO_SEQ:
217 {
218 status = phHciNfc_ReaderA_Update_Info(psHciContext,
219 HCI_READER_A_INFO_SEQ, NULL);
220#if defined( TYPE_B )
221 status = phHciNfc_ReaderB_Update_Info(psHciContext,
222 HCI_READER_B_INFO_SEQ, NULL);
223#endif /* end of #if defined(TYPE_B) */
224#if defined( TYPE_FELICA )
225 status = phHciNfc_Felica_Update_Info(psHciContext,
226 HCI_FELICA_INFO_SEQ, NULL);
227#endif /* end of #if defined(TYPE_FELICA) */
228#if defined( TYPE_JEWEL )
229 status = phHciNfc_Jewel_Update_Info(psHciContext,
230 HCI_JEWEL_INFO_SEQ, NULL);
231#endif /* end of #if defined(TYPE_JEWEL) */
232#if defined( TYPE_ISO15693 )
233 status = phHciNfc_ISO15693_Update_Info(psHciContext,
234 HCI_ISO_15693_INFO_SEQ, NULL);
235#endif /* end of #if defined(TYPE_ISO15693) */
236 break;
237 }
238 case REL_SEQ:
239 {
240 p_reader_mgmt_info->rf_gate_cur_seq = READERA_PIPE_CLOSE;
241 p_reader_mgmt_info->rf_gate_next_seq = END_READER_SEQUENCE;
242 break;
243 }
244 default:
245 {
246 break;
247 }
248 }
249 }
250 }
251
252 return status;
253
254}
255
256
257/*!
258 * \brief Initialisation of RF Reader Managment Gate.
259 *
260 * This function initialses the RF Reader Management gate and
261 * populates the Reader Management Information Structure
262 *
263 */
264
265NFCSTATUS
266phHciNfc_ReaderMgmt_Initialise(
267 phHciNfc_sContext_t *psHciContext,
268 void *pHwRef
269 )
270{
271 NFCSTATUS status = NFCSTATUS_SUCCESS;
272 phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
273 phHciNfc_ReaderMgmt_Info_t *p_reader_mgmt_info=NULL;
274
275 if( NULL == psHciContext )
276 {
277 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
278 }
279 else
280 {
281
282 if( ( NULL == psHciContext->p_reader_mgmt_info )
283 && (phHciNfc_Allocate_Resource((void **)(&p_reader_mgmt_info),
284 sizeof(phHciNfc_ReaderMgmt_Info_t))== NFCSTATUS_SUCCESS)
285 )
286 {
287 psHciContext->p_reader_mgmt_info = p_reader_mgmt_info;
288 p_reader_mgmt_info->rf_gate_cur_seq = READERA_PIPE_OPEN;
289 p_reader_mgmt_info->rf_gate_next_seq = END_READER_SEQUENCE;
290 }
291 else
292 {
293 p_reader_mgmt_info = (phHciNfc_ReaderMgmt_Info_t *)
294 psHciContext->p_reader_mgmt_info ;
295 }
296
297 if( NULL == psHciContext->p_reader_mgmt_info )
298 {
299 status = PHNFCSTVAL(CID_NFC_HCI,
300 NFCSTATUS_INSUFFICIENT_RESOURCES);
301 }
302#ifdef ESTABLISH_SESSION
303 else if( hciMode_Session == psHciContext->hci_mode )
304 {
305 status = NFCSTATUS_SUCCESS;
306 }
307#endif
308 else
309 {
310 switch(p_reader_mgmt_info->rf_gate_cur_seq )
311 {
312 /* Reader A pipe open sequence */
313 case READERA_PIPE_OPEN:
314 {
315 p_pipe_info = ((phHciNfc_ReaderA_Info_t *)
316 psHciContext->p_reader_a_info)->p_pipe_info;
317 if(NULL == p_pipe_info )
318 {
319 status = PHNFCSTVAL(CID_NFC_HCI,
320 NFCSTATUS_INVALID_HCI_SEQUENCE);
321 }
322 else
323 {
324 status = phHciNfc_Open_Pipe( psHciContext,
325 pHwRef, p_pipe_info );
326 if(status == NFCSTATUS_SUCCESS)
327 {
328 uint8_t rdr_enable = TRUE;
329 status = phHciNfc_ReaderA_Update_Info(
330 psHciContext, HCI_READER_A_ENABLE,
331 &rdr_enable);
332#if defined( TYPE_B ) && defined ( ENABLE_AUTO_ACTIVATE )
333 p_reader_mgmt_info->rf_gate_next_seq =
334 READERB_PIPE_OPEN;
335 status = NFCSTATUS_PENDING;
336/* end of #ifdef TYPE_B */
337#elif !defined( ENABLE_AUTO_ACTIVATE )
338 p_reader_mgmt_info->rf_gate_next_seq =
339 READERA_DISABLE_AUTO_ACTIVATE;
340 status = NFCSTATUS_PENDING;
341/* #ifdef ENABLE_AUTO_ACTIVATE */
342#elif defined( ENABLE_P2P )
343 p_reader_mgmt_info->rf_gate_next_seq =
344 NFCIP1_INITIATOR_PIPE_OPEN;
345 status = NFCSTATUS_PENDING;
346/* #ifdef ENABLE_P2P */
347#else
348 p_reader_mgmt_info->rf_gate_next_seq =
349 END_READER_SEQUENCE;
350 /* status = NFCSTATUS_PENDING; */
351#endif
352 }
353 }
354 break;
355 }
356 /* Reader A Auto Activate Disable */
357 case READERA_DISABLE_AUTO_ACTIVATE:
358 {
359 uint8_t activate_enable = FALSE;
360 p_pipe_info = ((phHciNfc_ReaderA_Info_t *)
361 psHciContext->p_reader_a_info)->p_pipe_info;
362 if(NULL == p_pipe_info )
363 {
364 status = PHNFCSTVAL(CID_NFC_HCI,
365 NFCSTATUS_INVALID_HCI_SEQUENCE);
366 }
367 else
368 {
369
370 status = phHciNfc_ReaderA_Auto_Activate( psHciContext,
371 pHwRef, activate_enable );
372 if(status == NFCSTATUS_SUCCESS)
373 {
374#if defined (TYPE_B)
375 p_reader_mgmt_info->rf_gate_next_seq =
376 READERB_PIPE_OPEN;
377 status = NFCSTATUS_PENDING;
378/* end of #ifdef TYPE_B */
379#elif defined(TYPE_FELICA)
380 p_reader_mgmt_info->rf_gate_next_seq =
381 FELICA_PROP_PIPE_OPEN;
382 status = NFCSTATUS_PENDING;
383/* end of #elif defined(TYPE_FELICA) */
384#elif defined(TYPE_JEWEL)
385 p_reader_mgmt_info->rf_gate_next_seq =
386 JEWEL_PROP_PIPE_OPEN;
387 status = NFCSTATUS_PENDING;
388/* end of #elif defined(TYPE_JEWEL) */
389#elif defined (TYPE_ISO15693)
390 p_reader_mgmt_info->rf_gate_next_seq =
391 ISO15693_PROP_PIPE_OPEN;
392 status = NFCSTATUS_PENDING;
393/* end of #elif defined(TYPE_ISO15693) */
394#elif defined(ENABLE_P2P)
395 p_reader_mgmt_info->rf_gate_next_seq =
396 NFCIP1_INITIATOR_PIPE_OPEN;
397 status = NFCSTATUS_PENDING;
398/* end of #ifdef ENABLE_P2P */
399#else
400 p_reader_mgmt_info->rf_gate_next_seq =
401 END_READER_SEQUENCE;
402 /* status = NFCSTATUS_PENDING; */
403#endif /* #if !defined(ENABLE_P2P) && !defined(TYPE_B)*/
404 }
405 }
406 break;
407 }
408#ifdef TYPE_B
409 /* Reader B pipe open sequence */
410 case READERB_PIPE_OPEN:
411 {
412 p_pipe_info = ((phHciNfc_ReaderB_Info_t *)
413 psHciContext->p_reader_b_info)->p_pipe_info;
414 if(NULL == p_pipe_info )
415 {
416 status = PHNFCSTVAL(CID_NFC_HCI,
417 NFCSTATUS_INVALID_HCI_SEQUENCE);
418 }
419 else
420 {
421 status = phHciNfc_Open_Pipe( psHciContext,
422 pHwRef, p_pipe_info );
423 if(status == NFCSTATUS_SUCCESS)
424 {
425#if defined(TYPE_FELICA)
426 p_reader_mgmt_info->rf_gate_next_seq =
427 FELICA_PROP_PIPE_OPEN;
428 status = NFCSTATUS_PENDING;
429/* end of #ifdef TYPE_FELICA */
430#elif defined(TYPE_JEWEL)
431 p_reader_mgmt_info->rf_gate_next_seq =
432 JEWEL_PROP_PIPE_OPEN;
433 status = NFCSTATUS_PENDING;
434/* end of #elif defined(TYPE_JEWEL) */
435#elif defined (TYPE_ISO15693)
436 p_reader_mgmt_info->rf_gate_next_seq =
437 ISO15693_PROP_PIPE_OPEN;
438 status = NFCSTATUS_PENDING;
439/* end of #elif defined(TYPE_ISO15693) */
440#elif defined(ENABLE_P2P)
441 p_reader_mgmt_info->rf_gate_next_seq =
442 NFCIP1_INITIATOR_PIPE_OPEN;
443 status = NFCSTATUS_PENDING;
444/* end of #ifdef ENABLE_P2P */
445#else
446 p_reader_mgmt_info->rf_gate_next_seq =
447 END_READER_SEQUENCE;
448 /* status = NFCSTATUS_PENDING; */
449#endif /* #if !defined(ENABLE_P2P) && !defined(TYPE_FELICA)*/
450 }
451 }
452 break;
453 }
454#endif /* #ifdef TYPE_B */
455#ifdef TYPE_FELICA
456 /* Felica Reader pipe open sequence */
457 case FELICA_PROP_PIPE_OPEN:
458 {
459 p_pipe_info = ((phHciNfc_Felica_Info_t *)
460 psHciContext->p_felica_info)->p_pipe_info;
461 if(NULL == p_pipe_info )
462 {
463 status = PHNFCSTVAL(CID_NFC_HCI,
464 NFCSTATUS_INVALID_HCI_SEQUENCE);
465 }
466 else
467 {
468 status = phHciNfc_Open_Pipe( psHciContext,
469 pHwRef, p_pipe_info );
470 if(status == NFCSTATUS_SUCCESS)
471 {
472#if defined(TYPE_JEWEL)
473 p_reader_mgmt_info->rf_gate_next_seq =
474 JEWEL_PROP_PIPE_OPEN;
475 status = NFCSTATUS_PENDING;
476/* end of #if defined(TYPE_JEWEL) */
477#elif defined (TYPE_ISO15693)
478 p_reader_mgmt_info->rf_gate_next_seq =
479 ISO15693_PROP_PIPE_OPEN;
480 status = NFCSTATUS_PENDING;
481/* end of #elif defined(TYPE_ISO15693) */
482#elif defined(ENABLE_P2P)
483 p_reader_mgmt_info->rf_gate_next_seq =
484 NFCIP1_INITIATOR_PIPE_OPEN;
485 status = NFCSTATUS_PENDING;
486 /* end of #ifdef ENABLE_P2P */
487#else
488 p_reader_mgmt_info->rf_gate_next_seq =
489 END_READER_SEQUENCE;
490 /* status = NFCSTATUS_PENDING; */
491#endif /* #if !defined(ENABLE_P2P) */
492 }
493 }
494 break;
495 }
496#endif
497#ifdef TYPE_JEWEL
498 /* Jewel Reader pipe open sequence */
499 case JEWEL_PROP_PIPE_OPEN:
500 {
501 p_pipe_info = ((phHciNfc_Jewel_Info_t *)
502 psHciContext->p_jewel_info)->p_pipe_info;
503 if(NULL == p_pipe_info )
504 {
505 status = PHNFCSTVAL(CID_NFC_HCI,
506 NFCSTATUS_INVALID_HCI_SEQUENCE);
507 }
508 else
509 {
510 status = phHciNfc_Open_Pipe( psHciContext,
511 pHwRef, p_pipe_info );
512 if(status == NFCSTATUS_SUCCESS)
513 {
514#if defined (TYPE_ISO15693)
515 p_reader_mgmt_info->rf_gate_next_seq =
516 ISO15693_PROP_PIPE_OPEN;
517 status = NFCSTATUS_PENDING;
518/* end of #if defined(TYPE_ISO15693) */
519#elif defined (ENABLE_P2P)
520 p_reader_mgmt_info->rf_gate_next_seq =
521 NFCIP1_INITIATOR_PIPE_OPEN;
522 status = NFCSTATUS_PENDING;
523 /* end of #ifdef ENABLE_P2P */
524#else
525 p_reader_mgmt_info->rf_gate_next_seq =
526 END_READER_SEQUENCE;
527 /* status = NFCSTATUS_PENDING; */
528#endif /* #if !defined(ENABLE_P2P) */
529 }
530 }
531 break;
532 }
533#endif
534
535#ifdef TYPE_ISO15693
536 /* ISO15693 Reader pipe open sequence */
537 case ISO15693_PROP_PIPE_OPEN:
538 {
539 p_pipe_info = ((phHciNfc_ISO15693_Info_t *)
540 psHciContext->p_iso_15693_info)->ps_15693_pipe_info;
541 if(NULL == p_pipe_info )
542 {
543 status = PHNFCSTVAL(CID_NFC_HCI,
544 NFCSTATUS_INVALID_HCI_SEQUENCE);
545 }
546 else
547 {
548 status = phHciNfc_Open_Pipe( psHciContext,
549 pHwRef, p_pipe_info );
550 if(status == NFCSTATUS_SUCCESS)
551 {
552#ifdef ENABLE_P2P
553 p_reader_mgmt_info->rf_gate_next_seq =
554 NFCIP1_INITIATOR_PIPE_OPEN;
555 status = NFCSTATUS_PENDING;
556 /* end of #ifdef ENABLE_P2P */
557#else
558 p_reader_mgmt_info->rf_gate_next_seq =
559 END_READER_SEQUENCE;
560 /* status = NFCSTATUS_PENDING; */
561#endif /* #if !defined(ENABLE_P2P) */
562 }
563 }
564 break;
565 }
566
567#endif
568
569#ifdef ENABLE_P2P
570 /* NFC-IP1 Initiator pipe open sequence */
571 case NFCIP1_INITIATOR_PIPE_OPEN:
572 {
573 p_pipe_info =
574 ((phHciNfc_NfcIP_Info_t *)psHciContext->
575 p_nfcip_info)->p_init_pipe_info;
576 if(NULL == p_pipe_info )
577 {
578 status = PHNFCSTVAL(CID_NFC_HCI,
579 NFCSTATUS_INVALID_HCI_SEQUENCE);
580 }
581 else
582 {
583 status = phHciNfc_Open_Pipe( psHciContext,
584 pHwRef, p_pipe_info );
585 if(status == NFCSTATUS_SUCCESS)
586 {
587 p_reader_mgmt_info->rf_gate_next_seq =
588 NFCIP1_INITIATOR_MODE_CONFIG;
589 status = NFCSTATUS_PENDING;
590 }
591 }
592 break;
593 }
594 case NFCIP1_INITIATOR_MODE_CONFIG:
595 {
Nick Pelly00c98d52011-03-18 11:27:49 -0700[diff] [blame]596 uint8_t mode = DEFAULT_NFCIP_INITIATOR_MODE_SUPPORT;
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]597 status = phHciNfc_NfcIP_SetMode( psHciContext, pHwRef,
598 NFCIP_INITIATOR, mode);
599 if(status == NFCSTATUS_PENDING )
600 {
601 p_reader_mgmt_info->rf_gate_next_seq =
602 NFCIP1_INITIATOR_PSL1_CONFIG;
603 /* status = NFCSTATUS_SUCCESS; */
604 }
605 break;
606 }
607 case NFCIP1_INITIATOR_PSL1_CONFIG:
608 {
609 uint8_t psl_config = NXP_NFCIP_PSL_BRS_DEFAULT;
610 status = phHciNfc_NfcIP_SetPSL1( psHciContext, pHwRef,
611 psl_config);
612 if(status == NFCSTATUS_PENDING )
613 {
614 p_reader_mgmt_info->rf_gate_next_seq =
615 END_READER_SEQUENCE;
616 status = NFCSTATUS_SUCCESS;
617 }
618 break;
619 }
620#endif
621 default:
622 {
623 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE);
624 break;
625 }
626
627 }/* End of the Sequence Switch */
628
629 }/* End of the Reader Info Memory Check */
630
631 } /* End of Null Context Check */
632
633 return status;
634}
635
636
637/*!
638 * \brief Initiate the Discovery for the RF Reader .
639 *
640 * This function starts the Polling Loop and initiates the discovery
641 * of the Target.
642 *
643 */
644static
645NFCSTATUS
646phHciNfc_ReaderMgmt_Initiate_Discovery(
647 phHciNfc_sContext_t *psHciContext,
648 void *pHwRef,
649 uint8_t reader_pipe_id
650 )
651{
652 NFCSTATUS status = NFCSTATUS_SUCCESS;
653
654 if( ( NULL == psHciContext )
655 || ( NULL == pHwRef )
656 || ( HCI_UNKNOWN_PIPE_ID == reader_pipe_id)
657 )
658 {
659 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
660 }
661 else
662 {
663
664 status = phHciNfc_Send_RFReader_Event ( psHciContext, pHwRef,
665 reader_pipe_id,(uint8_t) EVT_READER_REQUESTED );
666 status = ( (status == NFCSTATUS_PENDING)?
667 NFCSTATUS_SUCCESS : status);
668 }
669 return status;
670}
671
672
673/*!
674 * \brief End the Discovery of the RF Reader .
675 *
676 * This function stops the Polling Loop and ends the discovery
677 * of the Target.
678 *
679 */
680static
681NFCSTATUS
682phHciNfc_ReaderMgmt_End_Discovery(
683 phHciNfc_sContext_t *psHciContext,
684 void *pHwRef,
685 uint8_t reader_pipe_id
686 )
687{
688 NFCSTATUS status = NFCSTATUS_SUCCESS;
689
690 if( ( NULL == psHciContext )
691 || ( NULL == pHwRef )
692 || ( HCI_UNKNOWN_PIPE_ID == reader_pipe_id)
693 )
694 {
695 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
696 }
697 else
698 {
699
700 status = phHciNfc_Send_RFReader_Event ( psHciContext, pHwRef,
701 reader_pipe_id,(uint8_t) EVT_END_OPERATION );
702 status = ( (status == NFCSTATUS_PENDING)?
703 NFCSTATUS_SUCCESS : status);
704 }
705 return status;
706}
707
708
709/*!
710 * \brief Enable the Discovery of RF Reader Managment Gate.
711 *
712 * This function Enable the discovery of the RF Reader Management
713 * gate.
714 *
715 */
716
717
718NFCSTATUS
719phHciNfc_ReaderMgmt_Enable_Discovery(
720 phHciNfc_sContext_t *psHciContext,
721 void *pHwRef
722 )
723{
724 NFCSTATUS status = NFCSTATUS_SUCCESS;
725 phHciNfc_ReaderMgmt_Info_t *p_reader_mgmt_info=NULL;
726 uint8_t reader_pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
727 /* phHal_sADD_Cfg_t *p_poll_config = (phHal_sADD_Cfg_t * )
728 psHciContext->p_config_params; */
729 PHNFC_UNUSED_VARIABLE(p_reader_mgmt_info);
730 if( NULL != psHciContext->p_reader_mgmt_info )
731 {
732 uint8_t rdr_enable = FALSE;
733 p_reader_mgmt_info = (phHciNfc_ReaderMgmt_Info_t *)
734 psHciContext->p_reader_mgmt_info ;
735#ifdef TYPE_B
736 if ( (NULL != psHciContext->p_reader_b_info )
737 /* && (FALSE == rdr_enable) */
738 )
739 {
740 /* Get the Reader B Pipe ID */
741 status = phHciNfc_ReaderB_Get_PipeID
742 (psHciContext, &reader_pipe_id);
743
744 if( NFCSTATUS_SUCCESS == status )
745 {
746 rdr_enable = (uint8_t)TRUE;
747 /* rdr_enable = (uint8_t)
748 p_poll_config->PollDevInfo.PollCfgInfo.EnableIso14443B; */
749 status = phHciNfc_ReaderB_Update_Info(psHciContext,
750 HCI_RDR_ENABLE_TYPE, &rdr_enable);
751 }
752 }
753#endif
754#ifdef TYPE_FELICA
755 if ( (NULL != psHciContext->p_felica_info )
756 /* && (FALSE == rdr_enable) */
757 )
758 {
759 /* Get the Reader F Pipe ID */
760 status = phHciNfc_Felica_Get_PipeID
761 (psHciContext, &reader_pipe_id);
762
763 if( NFCSTATUS_SUCCESS == status )
764 {
765 rdr_enable = (uint8_t)TRUE;
766 /* rdr_enable = (uint8_t)
767 ( p_poll_config->PollDevInfo.PollCfgInfo.EnableFelica212
768 || p_poll_config->PollDevInfo.PollCfgInfo.EnableFelica424 ); */
769 status = phHciNfc_Felica_Update_Info(psHciContext,
770 HCI_RDR_ENABLE_TYPE, &rdr_enable);
771 }
772 }
773#endif
774#ifdef TYPE_JEWEL
775 if ( (NULL != psHciContext->p_jewel_info )
776 /* && (FALSE == rdr_enable) */
777 )
778 {
779 /* Get the Reader F Pipe ID */
780 status = phHciNfc_Jewel_Get_PipeID
781 (psHciContext, &reader_pipe_id);
782
783 if( NFCSTATUS_SUCCESS == status )
784 {
785 rdr_enable = (uint8_t)TRUE;
786 status = phHciNfc_Jewel_Update_Info(psHciContext,
787 HCI_RDR_ENABLE_TYPE, &rdr_enable);
788 }
789 }
790#endif /* #ifdef TYPE_JEWEL */
791#if defined(TYPE_ISO15693)
792 if ( (NULL != psHciContext->p_iso_15693_info )
793 /* && (FALSE == rdr_enable) */
794 )
795 {
796 /* Get the Reader F Pipe ID */
797 status = phHciNfc_ISO15693_Get_PipeID
798 (psHciContext, &reader_pipe_id);
799
800 if( NFCSTATUS_SUCCESS == status )
801 {
802 rdr_enable = (uint8_t)TRUE;
803 status = phHciNfc_ISO15693_Update_Info(psHciContext,
804 HCI_RDR_ENABLE_TYPE, &rdr_enable);
805 }
806 }
807
808/* end of #elif defined(TYPE_ISO15693) */
809#endif
810
811 if(NULL != psHciContext->p_reader_a_info)
812 {
813 /* Get the Reader A Pipe ID */
814 status = phHciNfc_ReaderA_Get_PipeID
815 (psHciContext, &reader_pipe_id);
816
817 if( NFCSTATUS_SUCCESS == status )
818 {
819 rdr_enable = (uint8_t)TRUE;
820 status = phHciNfc_ReaderA_Update_Info(psHciContext,
821 HCI_RDR_ENABLE_TYPE, &rdr_enable);
822 }
823
824 }
825 if( ( NFCSTATUS_SUCCESS == status )
826 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
827 )
828 {
829 status = phHciNfc_ReaderMgmt_Initiate_Discovery( psHciContext,
830 pHwRef, reader_pipe_id);
831 }
832
833 }/* End of the Reader Info Memory Check */
834
835 return status;
836}
837
838/*!
839 * \brief Disable the Discovery of RF Reader Managment Gate.
840 *
841 * This function Disable the discovery of the RF Reader Management
842 * gate.
843 *
844 */
845
846NFCSTATUS
847phHciNfc_ReaderMgmt_Disable_Discovery(
848 phHciNfc_sContext_t *psHciContext,
849 void *pHwRef
850 )
851{
852 NFCSTATUS status = NFCSTATUS_FAILED;
853 phHciNfc_ReaderMgmt_Info_t *p_reader_mgmt_info=NULL;
854 uint8_t reader_pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
855 /* phHal_sADD_Cfg_t *p_poll_config = (phHal_sADD_Cfg_t * )
856 psHciContext->p_config_params; */
857 PHNFC_UNUSED_VARIABLE(p_reader_mgmt_info);
858 if( NULL != psHciContext->p_reader_mgmt_info )
859 {
860 p_reader_mgmt_info = (phHciNfc_ReaderMgmt_Info_t *)
861 psHciContext->p_reader_mgmt_info ;
862 if(NULL != psHciContext->p_reader_a_info)
863 {
864 /* Get the Reader A Pipe ID */
865 status = phHciNfc_ReaderA_Get_PipeID
866 (psHciContext, &reader_pipe_id);
867#if 0
868 if( NFCSTATUS_SUCCESS == status )
869 {
870 uint8_t rdr_enable = (uint8_t) FALSE;
871 status = phHciNfc_ReaderA_Update_Info(psHciContext,
872 HCI_RDR_ENABLE_TYPE, &rdr_enable);
873 }
874#endif
875
876 }
877#ifdef TYPE_B
878 else if((NULL != psHciContext->p_reader_b_info )
879 /* && (NFCSTATUS_SUCCESS != status) */
880 )
881 {
882 /* Get the Reader B Pipe ID */
883 status = phHciNfc_ReaderB_Get_PipeID
884 (psHciContext, &reader_pipe_id);
885 }
886#endif
887#ifdef TYPE_FELICA
888 else if((NULL != psHciContext->p_felica_info )
889 /* && (NFCSTATUS_SUCCESS != status) */
890 )
891 {
892 /* Get the Reader B Pipe ID */
893 status = phHciNfc_Felica_Get_PipeID
894 (psHciContext, &reader_pipe_id);
895 }
896#endif
897#ifdef TYPE_JEWEL
898 else if((NULL != psHciContext->p_jewel_info )
899 /* && (NFCSTATUS_SUCCESS != status) */
900 )
901 {
902 /* Get the Reader B Pipe ID */
903 status = phHciNfc_Jewel_Get_PipeID
904 (psHciContext, &reader_pipe_id);
905 }
906#endif /* #ifdef TYPE_JEWEL */
907#ifdef TYPE_ISO15693
908 else if((NULL != psHciContext->p_iso_15693_info )
909 /* && (NFCSTATUS_SUCCESS != status) */
910 )
911 {
912 /* Get the Reader B Pipe ID */
913 status = phHciNfc_ISO15693_Get_PipeID
914 (psHciContext, &reader_pipe_id);
915 }
916#endif /* #ifdef TYPE_ISO15693 */
917
918 else
919 {
920 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_NOT_ALLOWED);
921 }
922
923 if( (NFCSTATUS_SUCCESS == status)
924 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
925 )
926 {
927 status = phHciNfc_ReaderMgmt_End_Discovery( psHciContext,
928 pHwRef, reader_pipe_id);
929 }
930
931 }/* End of the Reader Info Memory Check */
932
933 return status;
934}
935
936
937
938
939/*!
940* \brief Updates the Sequence of RF Reader Managment Gate.
941*
942* This function Resets/Updates the sequence of the RF Reader Management
943* gate.
944*
945*/
946
947NFCSTATUS
948phHciNfc_ReaderMgmt_Info_Sequence(
949 phHciNfc_sContext_t *psHciContext,
950 void *pHwRef
951 )
952{
953#if defined(NXP_NFCIP_ACTIVATE_DELAY)
954 static uint8_t nfc_atr_retry = 0;
955#endif
956 NFCSTATUS status = NFCSTATUS_SUCCESS;
957 phHciNfc_ReaderMgmt_Info_t *p_reader_mgmt_info=NULL;
958#if 0
959 uint8_t reader_pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
960 phHal_eRemDevType_t target_type = phHal_eUnknown_DevType;
961#endif
962
963
964 PHNFC_UNUSED_VARIABLE(p_reader_mgmt_info);
965 if( NULL == psHciContext )
966 {
967 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
968 }
969 else
970 {
971 if( NULL != psHciContext->p_reader_mgmt_info )
972 {
973 p_reader_mgmt_info = (phHciNfc_ReaderMgmt_Info_t *)
974 psHciContext->p_reader_mgmt_info ;
975 switch( psHciContext->host_rf_type )
976 {
977
978 case phHal_eISO14443_A_PCD:
979 {
980 /* If the Target Info is updated then the Target
981 * is connected.
982 */
983 if(NULL == psHciContext->p_target_info)
984 {
985#if defined(NXP_NFCIP_ACTIVATE_DELAY)
986 nfc_atr_retry = 0;
987#endif
988 status = phHciNfc_ReaderA_Info_Sequence(
989 psHciContext, pHwRef );
990 }
991 else
992 {
993 status = phHciNfc_ReaderA_App_Data(
994 psHciContext, pHwRef );
995 status = ((NFCSTATUS_PENDING == status )?
996 NFCSTATUS_SUCCESS : status);
997 }
998 break;
999 }
1000#ifdef ENABLE_P2P
1001 case phHal_eNfcIP1_Initiator:
1002 {
1003 /* If the Target Info is updated then the Target
1004 * is connected.
1005 */
1006#ifdef NFCIP_CHECK
1007 if(NULL == psHciContext->p_target_info)
1008#endif
1009 {
1010 status = phHciNfc_NfcIP_Info_Sequence(
1011 psHciContext, pHwRef
1012#ifdef NOTIFY_REQD
1013 ,(NULL == psHciContext->p_target_info)
1014#endif /* #ifdef NOTIFY_REQD */
1015 );
1016 }
1017#ifdef NFCIP_CHECK
1018 else
1019 {
1020 status = phHciNfc_NfcIP_GetATRInfo(
1021 psHciContext, pHwRef, NFCIP_INITIATOR );
1022#if defined(NXP_NFCIP_ACTIVATE_DELAY)
1023 if (
1024 (NFCSTATUS_PENDING == status)
1025 && ( NFCIP_ACTIVATE_DELAY <= nfc_atr_retry)
1026 )
1027 {
1028 nfc_atr_retry = 0;
1029 status = NFCSTATUS_SUCCESS;
1030 }
1031 else
1032 {
1033 nfc_atr_retry++;
1034 }
1035#else
1036 status = ((NFCSTATUS_PENDING == status )?
1037 NFCSTATUS_SUCCESS : status);
1038#endif
1039 }
1040#endif
1041 break;
1042 }
1043#endif
1044#ifdef TYPE_B
1045 case phHal_eISO14443_B_PCD:
1046 {
1047 if(NULL == psHciContext->p_target_info)
1048 {
1049 status = phHciNfc_ReaderB_Info_Sequence(
1050 psHciContext, pHwRef );
1051 }
1052 break;
1053 }
1054#endif /* #ifdef TYPE_B */
1055#ifdef TYPE_FELICA
1056 case phHal_eFelica_PCD:
1057 {
1058 if(NULL == psHciContext->p_target_info)
1059 {
1060#if defined(NXP_NFCIP_ACTIVATE_DELAY)
1061 nfc_atr_retry = 0;
1062#endif
1063 status = phHciNfc_Felica_Info_Sequence(
1064 psHciContext, pHwRef );
1065 }
1066 break;
1067 }
1068#endif /* #ifdef TYPE_FELICA */
1069#ifdef TYPE_JEWEL
1070 case phHal_eJewel_PCD:
1071 {
1072 if(NULL == psHciContext->p_target_info)
1073 {
1074 status = phHciNfc_Jewel_Info_Sequence(
1075 psHciContext, pHwRef );
1076 }
1077 break;
1078 }
1079#endif /* #ifdef TYPE_JEWEL */
1080#if defined(TYPE_ISO15693)
1081 case phHal_eISO15693_PCD:
1082 {
1083 if(NULL == psHciContext->p_target_info)
1084 {
1085 status = phHciNfc_ISO15693_Info_Sequence(
1086 psHciContext, pHwRef );
1087 }
1088 break;
1089 }
1090#endif
1091 default:
1092 {
1093 break;
1094 }
1095 }
1096
1097 }/* End of the Reader Info Memory Check */
1098
1099 } /* End of Null Context Check */
1100
1101 return status;
1102
1103}
1104
1105
1106/*!
1107 * \brief Connects the the selected tag via RF Reader Gates.
1108 *
1109 * This function connects the selected tags via RF Reader Gate.
1110 * This function uses the RF Reader gate based on the type of the
1111 * tag specified.
1112 */
1113
1114
1115NFCSTATUS
1116phHciNfc_ReaderMgmt_Select(
1117 phHciNfc_sContext_t *psHciContext,
1118 void *pHwRef,
1119 phHal_eRemDevType_t target_type
1120 )
1121{
1122 NFCSTATUS status = NFCSTATUS_SUCCESS;
1123 uint8_t reader_pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
1124
1125 if( (NULL == psHciContext) || (NULL == pHwRef) )
1126 {
1127 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1128 }
1129 else
1130 {
1131 switch (target_type)
1132 {
1133 case phHal_eMifare_PICC:
1134 case phHal_eISO14443_3A_PICC:
1135 {
1136 /* Get the Reader A Pipe ID */
1137 status = phHciNfc_ReaderA_Get_PipeID
1138 (psHciContext, &reader_pipe_id);
1139
1140 if( (NFCSTATUS_SUCCESS == status)
1141 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1142 )
1143 {
1144 status = phHciNfc_ReaderMgmt_Reactivate(
1145 psHciContext, pHwRef, target_type );
1146 }
1147 break;
1148 }
1149 case phHal_eISO14443_A_PICC:
1150 case phHal_eISO14443_4A_PICC:
1151 {
1152#ifdef ENABLE_AUTO_ACTIVATE
1153 /* Get the Reader A Pipe ID */
1154 status = phHciNfc_ReaderA_Get_PipeID
1155 (psHciContext, &reader_pipe_id);
1156
1157 if( (NFCSTATUS_SUCCESS == status)
1158 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1159 )
1160 {
1161 status = phHciNfc_Send_RFReader_Command (psHciContext,
1162 pHwRef, reader_pipe_id, NXP_WR_PRESCHECK );
1163 }
1164#else
1165 status = phHciNfc_ReaderA_Cont_Activate(
1166 psHciContext, pHwRef);
1167#endif /* #ifdef ENABLE_AUTO_ACTIVATE */
1168 break;
1169 }
1170#ifdef TYPE_B
1171 case phHal_eISO14443_B_PICC:
1172 case phHal_eISO14443_4B_PICC:
1173 {
1174 /* Get the Reader B Pipe ID */
1175 status = phHciNfc_ReaderB_Get_PipeID
1176 (psHciContext, &reader_pipe_id);
1177
1178 if( (NFCSTATUS_SUCCESS == status)
1179 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1180 )
1181 {
1182 status = phHciNfc_Send_RFReader_Command (psHciContext,
1183 pHwRef, reader_pipe_id, NXP_WR_PRESCHECK );
1184 /* status = phHciNfc_ReaderA_Set_DataRateMax(
1185 psHciContext, pHwRef,
1186 DATA_RATE_MAX_DEFAULT_VALUE ); */
1187 /* status = phHciNfc_ReaderMgmt_Reactivate(
1188 psHciContext, pHwRef, target_type ); */
1189 }
1190 break;
1191 }
1192#endif /* #ifdef TYPE_B */
1193#ifdef TYPE_FELICA
1194 case phHal_eFelica_PICC:
1195 {
1196 status = phHciNfc_Felica_Get_PipeID
1197 (psHciContext, &reader_pipe_id);
1198
1199 if( (NFCSTATUS_SUCCESS == status)
1200 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1201 )
1202 {
1203 /* Get the Reader Felica Pipe ID */
1204 /* status = phHciNfc_ReaderA_Set_DataRateMax(
1205 psHciContext, pHwRef,
1206 DATA_RATE_MAX_DEFAULT_VALUE ); */
1207 status = phHciNfc_ReaderMgmt_Reactivate(
1208 psHciContext, pHwRef, target_type );
1209 }
1210 break;
1211 }
1212#endif /* #ifdef TYPE_FELICA */
1213#ifdef TYPE_JEWEL
1214 case phHal_eJewel_PICC:
1215 {
1216 /* Get the Reader jewel Pipe ID */
1217 status = phHciNfc_Jewel_Get_PipeID
1218 (psHciContext, &reader_pipe_id);
1219
1220 if( (NFCSTATUS_SUCCESS == status)
1221 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1222 )
1223 {
1224 status = phHciNfc_Jewel_GetRID(
1225 psHciContext, pHwRef);
1226 }
1227 break;
1228 }
1229#endif /* #ifdef TYPE_JEWEL */
1230#ifdef TYPE_ISO15693
1231 case phHal_eISO15693_PICC:
1232 {
1233 /* Get the Reader ISO 15693 Pipe ID */
1234 status = phHciNfc_ISO15693_Get_PipeID
1235 (psHciContext, &reader_pipe_id);
1236
1237 if( (NFCSTATUS_SUCCESS == status)
1238 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1239 )
1240 {
1241 /* TODO */
1242 status = phHciNfc_ReaderA_Set_DataRateMax(
1243 psHciContext, pHwRef,
1244 DATA_RATE_MAX_DEFAULT_VALUE );
1245 }
1246 break;
1247 }
1248#endif /* #ifdef TYPE_ISO15693 */
1249#ifdef ENABLE_P2P
1250 case phHal_eNfcIP1_Target:
1251 {
1252 if ( (phHal_eISO14443_A_PCD ==
1253 psHciContext->host_rf_type )
1254 || (phHal_eFelica_PCD ==
1255 psHciContext->host_rf_type )
1256 )
1257 {
1258 status = phHciNfc_Initiator_Cont_Activate(
1259 psHciContext, pHwRef);
1260 }
1261 else
1262 {
1263 status = phHciNfc_NfcIP_Presence_Check (psHciContext, pHwRef);
1264 }
1265 break;
1266 }
1267#endif
1268#if 0
1269 case phHal_eNfcIP1_Initiator:
1270 {
1271
1272 break;
1273 }
1274#endif
1275 default:
1276 {
1277 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1278 break;
1279 }
1280
1281 } /* End of the tag_type Switch */
1282 }
1283
1284 return status;
1285}
1286
1287NFCSTATUS
1288phHciNfc_ReaderMgmt_UICC_Dispatch(
1289 phHciNfc_sContext_t *psHciContext,
1290 void *pHwRef,
1291 phHal_eRemDevType_t target_type
1292 )
1293{
1294 NFCSTATUS status = NFCSTATUS_SUCCESS;
1295 uint8_t reader_pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
1296 phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
1297
1298
1299 if( (NULL == psHciContext) || (NULL == pHwRef) )
1300 {
1301 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1302 }
1303 else if (NULL == psHciContext->p_target_info)
1304 {
1305 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
1306 }
1307 else
1308 {
1309 switch (target_type)
1310 {
1311 case phHal_eISO14443_A_PICC:
1312 case phHal_eISO14443_4A_PICC:
1313 {
1314 /* Get the Reader A Pipe ID */
1315 status = phHciNfc_ReaderA_Get_PipeID(
1316 psHciContext, &reader_pipe_id);
1317 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
1318 p_pipe_info->param_info = &psHciContext->p_target_info->
1319 RemoteDevInfo.Iso14443A_Info.Uid;
1320 p_pipe_info->param_length = psHciContext->p_target_info->
1321 RemoteDevInfo.Iso14443A_Info.UidLength;
1322
1323 break;
1324 }
1325#ifdef TYPE_B
1326 case phHal_eISO14443_B_PICC:
1327 case phHal_eISO14443_4B_PICC:
1328 {
1329 /* Get the Reader B Pipe ID */
1330 status = phHciNfc_ReaderB_Get_PipeID
1331 (psHciContext, &reader_pipe_id);
1332
1333 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
1334 p_pipe_info->param_info = &psHciContext->p_target_info->
1335 RemoteDevInfo.Iso14443B_Info.AtqB.AtqResInfo.Pupi;
1336 p_pipe_info->param_length = PHHAL_PUPI_LENGTH;
1337 break;
1338 }
1339#endif /* #ifdef TYPE_B */
1340 case phHal_eMifare_PICC:
1341 case phHal_eISO14443_3A_PICC:
1342 default:
1343 {
1344 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1345 break;
1346 }
1347
1348 } /* End of the tag_type Switch */
1349 }
1350 if( (NFCSTATUS_SUCCESS == status)
1351 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1352 )
1353 {
1354 status = phHciNfc_Send_RFReader_Command (psHciContext,
1355 pHwRef, reader_pipe_id, NXP_WR_DISPATCH_TO_UICC );
1356 }
1357
1358 return status;
1359}
1360
1361
1362NFCSTATUS
1363phHciNfc_ReaderMgmt_Reactivate(
1364 phHciNfc_sContext_t *psHciContext,
1365 void *pHwRef,
1366 phHal_eRemDevType_t target_type
1367 )
1368{
1369 NFCSTATUS status = NFCSTATUS_SUCCESS;
1370 uint8_t reader_pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
1371 phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
1372
1373
1374 if( (NULL == psHciContext) || (NULL == pHwRef) )
1375 {
1376 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1377 }
1378 else if (NULL == psHciContext->p_target_info)
1379 {
1380 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
1381 }
1382 else
1383 {
1384 switch (target_type)
1385 {
1386 case phHal_eISO14443_A_PICC:
1387 case phHal_eMifare_PICC:
1388 case phHal_eISO14443_4A_PICC:
1389 case phHal_eISO14443_3A_PICC:
1390 {
1391 /* Get the Reader A Pipe ID */
1392 status = phHciNfc_ReaderA_Get_PipeID(
1393 psHciContext, &reader_pipe_id);
1394 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
1395 p_pipe_info->param_info = &psHciContext->p_target_info->
1396 RemoteDevInfo.Iso14443A_Info.Uid;
1397 p_pipe_info->param_length = psHciContext->p_target_info->
1398 RemoteDevInfo.Iso14443A_Info.UidLength;
1399
1400 break;
1401 }
1402#ifdef TYPE_B
1403 case phHal_eISO14443_B_PICC:
1404 case phHal_eISO14443_4B_PICC:
1405 {
1406 /* Get the Reader B Pipe ID */
1407 status = phHciNfc_ReaderB_Get_PipeID
1408 (psHciContext, &reader_pipe_id);
1409
1410 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
1411 p_pipe_info->param_info = &psHciContext->p_target_info->
1412 RemoteDevInfo.Iso14443B_Info.AtqB.AtqResInfo.Pupi;
1413 p_pipe_info->param_length = PHHAL_PUPI_LENGTH;
1414 break;
1415 }
1416#endif /* #ifdef TYPE_B */
1417#ifdef TYPE_FELICA
1418 case phHal_eFelica_PICC:
1419 {
1420 /* Get the Felica Reader Pipe ID */
1421 status = phHciNfc_Felica_Get_PipeID
1422 (psHciContext, &reader_pipe_id);
1423
1424 if( (NFCSTATUS_SUCCESS == status)
1425 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1426 )
1427 {
1428 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
1429 p_pipe_info->param_info = &psHciContext->p_target_info->
1430 RemoteDevInfo.Felica_Info.IDm;
1431 p_pipe_info->param_length = PHHAL_FEL_ID_LEN;
1432 }
1433 break;
1434 }
1435#endif /* #ifdef TYPE_FELICA */
1436#ifdef ENABLE_P2P
1437 case phHal_eNfcIP1_Target:
1438 {
1439 /* Get the Initiator Pipe ID */
1440 status = phHciNfc_Initiator_Get_PipeID(
1441 psHciContext, &reader_pipe_id);
1442 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
1443 p_pipe_info->param_info = &psHciContext->p_target_info->
1444 RemoteDevInfo.NfcIP_Info.NFCID;
1445 p_pipe_info->param_length = psHciContext->p_target_info->
1446 RemoteDevInfo.NfcIP_Info.NFCID_Length;
1447 break;
1448 }
1449 case phHal_eNfcIP1_Initiator:
1450 {
1451 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1452 break;
1453 }
1454#endif /* #ifdef ENABLE_P2P */
1455 default:
1456 {
1457 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1458 break;
1459 }
1460
1461 } /* End of the tag_type Switch */
1462 }
1463 if( (NFCSTATUS_SUCCESS == status)
1464 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1465 )
1466 {
1467 status = phHciNfc_Send_RFReader_Command (psHciContext,
1468 pHwRef, reader_pipe_id, NXP_WR_ACTIVATE_ID );
1469 }
1470
1471 return status;
1472}
1473
1474
1475/*!
1476* \brief Activates the next Remote Target in the field.
1477*
1478* This function selects and activates the next tag present in the field.
1479*/
1480
1481
1482NFCSTATUS
1483phHciNfc_ReaderMgmt_Activate_Next(
1484 phHciNfc_sContext_t *psHciContext,
1485 void *pHwRef
1486 )
1487{
1488 NFCSTATUS status = NFCSTATUS_SUCCESS;
1489 /* phHciNfc_Pipe_Info_t *p_pipe_info = NULL; */
1490 uint8_t reader_pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
1491
1492 if( (NULL == psHciContext) || (NULL == pHwRef) )
1493 {
1494 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1495 }
1496 else
1497 {
1498 switch ( psHciContext->host_rf_type )
1499 {
1500 case phHal_eISO14443_A_PCD:
1501 {
1502 /* Get the Reader A Pipe ID */
1503 status = phHciNfc_ReaderA_Get_PipeID
1504 (psHciContext, &reader_pipe_id);
1505
1506 break;
1507 }
1508#ifdef TYPE_B
1509 case phHal_eISO14443_B_PCD:
1510 {
1511 /* Get the Reader B Pipe ID */
1512 status = phHciNfc_ReaderB_Get_PipeID
1513 (psHciContext, &reader_pipe_id);
1514
1515 break;
1516 }
1517#endif /* #ifdef TYPE_B */
1518#ifdef TYPE_FELICA
1519 case phHal_eFelica_PCD:
1520 {
1521 /* Get the Felica Reader Pipe ID */
1522 status = phHciNfc_Felica_Get_PipeID
1523 (psHciContext, &reader_pipe_id);
1524
1525 break;
1526 }
1527#endif /* #ifdef TYPE_FELICA */
aferire1b8bff2010-11-02 22:57:43 -0500[diff] [blame]1528#ifdef TYPE_ISO15693
1529 case phHal_eISO15693_PCD:
1530 {
1531 /* Get the ISO 15693 Reader Pipe ID */
1532 status = phHciNfc_ISO15693_Get_PipeID
1533 (psHciContext, &reader_pipe_id);
1534
1535 break;
1536 }
1537#endif /* #ifdef TYPE_ISO15693 */
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1538 default:
1539 {
1540 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1541 break;
1542 }
1543
1544 } /* End of the reader_type Switch */
1545 if( (NFCSTATUS_SUCCESS == status)
1546 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1547 )
1548 {
1549 status = phHciNfc_Send_RFReader_Command (psHciContext,
1550 pHwRef, reader_pipe_id, NXP_WR_ACTIVATE_NEXT );
1551 }
1552
1553 }
1554
1555 return status;
1556
1557}
1558
1559/*!
1560* \brief Checks the presence of the Remote Target in the field.
1561*
1562* This function checks the presence of the tag present in the field.
1563*/
1564
1565
1566NFCSTATUS
1567phHciNfc_ReaderMgmt_Presence_Check(
1568 phHciNfc_sContext_t *psHciContext,
1569 void *pHwRef
1570 )
1571{
1572 NFCSTATUS status = NFCSTATUS_SUCCESS;
1573 /* phHciNfc_Pipe_Info_t *p_pipe_info = NULL; */
1574 uint8_t reader_pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
1575 phHal_eRemDevType_t target_type = phHal_eUnknown_DevType;
1576
1577 if( (NULL == psHciContext) || (NULL == pHwRef) )
1578 {
1579 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1580 }
1581 else
1582 {
1583 target_type = psHciContext->p_target_info->RemDevType;
1584 switch (target_type)
1585 {
1586 case phHal_eMifare_PICC:
1587 case phHal_eISO14443_3A_PICC:
1588 {
1589 /* Get the Reader A Pipe ID */
1590 status = phHciNfc_ReaderA_Get_PipeID
1591 (psHciContext, &reader_pipe_id);
1592
1593 if( (NFCSTATUS_SUCCESS == status)
1594 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1595 )
1596 {
1597 status = phHciNfc_ReaderMgmt_Reactivate(
1598 psHciContext, pHwRef, target_type );
1599 }
1600 break;
1601 }
1602 case phHal_eISO14443_A_PICC:
1603 case phHal_eISO14443_4A_PICC:
1604 {
1605 /* Get the Reader A Pipe ID */
1606 status = phHciNfc_ReaderA_Get_PipeID
1607 (psHciContext, &reader_pipe_id);
1608
1609 if( (NFCSTATUS_SUCCESS == status)
1610 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1611 )
1612 {
1613 status = phHciNfc_Send_RFReader_Command (psHciContext,
1614 pHwRef, reader_pipe_id, NXP_WR_PRESCHECK );
1615 }
1616 break;
1617 }
1618#ifdef ENABLE_P2P
1619 case phHal_eNfcIP1_Target:
1620 {
1621 status = phHciNfc_NfcIP_Presence_Check (psHciContext, pHwRef);
1622 break;
1623 }
1624#endif
1625#ifdef TYPE_B
1626 case phHal_eISO14443_B_PICC:
1627 case phHal_eISO14443_4B_PICC:
1628 {
1629 /* Get the Reader B Pipe ID */
1630 status = phHciNfc_ReaderB_Get_PipeID
1631 (psHciContext, &reader_pipe_id);
1632
1633 if( (NFCSTATUS_SUCCESS == status)
1634 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1635 )
1636 {
1637 status = phHciNfc_Send_RFReader_Command (psHciContext,
1638 pHwRef, reader_pipe_id, NXP_WR_PRESCHECK );
1639 }
1640 break;
1641 }
1642#endif /* #ifdef TYPE_B */
1643#ifdef TYPE_FELICA
1644 case phHal_eFelica_PICC:
1645 {
1646 /* Get the Felica Reader Pipe ID */
1647 status = phHciNfc_Felica_Get_PipeID
1648 (psHciContext, &reader_pipe_id);
1649
1650 if( (NFCSTATUS_SUCCESS == status)
1651 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1652 )
1653 {
1654 status = phHciNfc_Felica_Request_Mode(psHciContext, pHwRef);
1655 }
1656 break;
1657 }
1658#endif /* #ifdef TYPE_FELICA */
1659#ifdef TYPE_JEWEL
1660 case phHal_eJewel_PICC:
1661 {
1662 /* Get the Jewel Reader Pipe ID */
1663 status = phHciNfc_Jewel_Get_PipeID
1664 (psHciContext, &reader_pipe_id);
1665
1666 if( (NFCSTATUS_SUCCESS == status)
1667 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1668 )
1669 {
1670 /* status = PHNFCSTVAL(CID_NFC_HCI,
1671 NFCSTATUS_FEATURE_NOT_SUPPORTED); */
1672 status = phHciNfc_Jewel_GetRID(
1673 psHciContext, pHwRef);
1674 }
1675 break;
1676 }
1677#endif /* #ifdef TYPE_JEWEL */
1678#ifdef TYPE_ISO15693
1679 case phHal_eISO15693_PICC:
1680 {
1681 /* Get the Reader ISO 15693 Pipe ID */
1682 status = phHciNfc_ISO15693_Get_PipeID
1683 (psHciContext, &reader_pipe_id);
1684
1685 if( (NFCSTATUS_SUCCESS == status)
1686 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1687 )
1688 {
Martijn Coenenfa199fc2010-11-02 08:53:36 -0600[diff] [blame]1689 uint8_t cmd[11];
1690 phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1691 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
Martijn Coenenfa199fc2010-11-02 08:53:36 -0600[diff] [blame]1692 p_pipe_info->param_info = &cmd;
1693 p_pipe_info->param_length = 11;
1694 // masked inventory command:
1695 // set #slots to 1 to use mask without padding,
1696 // need to set inventory flag to enable setting #slots
1697 cmd[0] = 0x04 | 0x20; // FLAG_INVENTORY | FLAG_SLOTS
1698 cmd[1] = 0x01; // CMD_INVENTORY
1699 cmd[2] = 64; // mask bit-length
1700 memcpy(cmd + 3, &(psHciContext->p_target_info->RemoteDevInfo.Iso15693_Info.Uid), 8);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1701 status = phHciNfc_Send_ISO15693_Command(
1702 psHciContext, pHwRef
1703 ,reader_pipe_id, NXP_ISO15693_CMD );
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]1704
1705 }
1706 break;
1707 }
1708#endif /* #ifdef TYPE_ISO15693 */
1709 default:
1710 {
1711 status = PHNFCSTVAL(CID_NFC_HCI,
1712 NFCSTATUS_FEATURE_NOT_SUPPORTED);
1713 break;
1714 }
1715
1716 } /* End of the tag_type Switch */
1717 }
1718
1719 return status;
1720
1721}
1722
1723
1724/*!
1725 * \brief Disconnects the the selected tag.
1726 *
1727 * This function disconnects the selected tags via RF Reader Gate.
1728 * This function uses the RF Reader gate based on the type of the
1729 * tag specified.
1730 */
1731
1732
1733NFCSTATUS
1734phHciNfc_ReaderMgmt_Deselect(
1735 phHciNfc_sContext_t *psHciContext,
1736 void *pHwRef,
1737 phHal_eRemDevType_t target_type,
1738 uint8_t re_poll
1739 )
1740{
1741 static uint8_t rls_param = FALSE;
1742 NFCSTATUS status = NFCSTATUS_SUCCESS;
1743 uint8_t reader_pipe_id =
1744 (uint8_t) HCI_UNKNOWN_PIPE_ID;
1745 phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
1746
1747
1748
1749 if( (NULL == psHciContext)
1750 || (NULL == pHwRef)
1751 )
1752 {
1753 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1754 }
1755 else
1756 {
1757 rls_param = re_poll;
1758
1759 switch (target_type)
1760 {
1761 case phHal_eMifare_PICC:
1762 case phHal_eISO14443_A_PICC:
1763 case phHal_eISO14443_3A_PICC:
1764 case phHal_eISO14443_4A_PICC:
1765 {
1766 /* Get the Reader A Pipe ID */
1767 status = phHciNfc_ReaderA_Get_PipeID
1768 (psHciContext, &reader_pipe_id);
1769 break;
1770 }
1771#ifdef TYPE_B
1772 case phHal_eISO14443_B_PICC:
1773 case phHal_eISO14443_4B_PICC:
1774 {
1775 /* Get the Reader B Pipe ID */
1776 status = phHciNfc_ReaderB_Get_PipeID
1777 (psHciContext, &reader_pipe_id);
1778
1779 break;
1780 }
1781#endif /* #ifdef TYPE_B */
1782#ifdef TYPE_FELICA
1783 case phHal_eFelica_PICC:
1784 {
1785 /* Get the Felica Pipe ID */
1786 status = phHciNfc_Felica_Get_PipeID
1787 (psHciContext, &reader_pipe_id);
1788
1789 break;
1790 }
1791#endif /* #ifdef TYPE_FELICA */
1792#ifdef TYPE_JEWEL
1793 case phHal_eJewel_PICC:
1794 {
1795 /* Get the Jewel Pipe ID */
1796 status = phHciNfc_Jewel_Get_PipeID
1797 (psHciContext, &reader_pipe_id);
1798
1799 break;
1800 }
1801#endif /* #ifdef TYPE_JEWEL */
1802#ifdef TYPE_ISO15693
1803 case phHal_eISO15693_PICC:
1804 {
1805 /* Get the ISO 15693 Pipe ID */
1806 status = phHciNfc_ISO15693_Get_PipeID
1807 (psHciContext, &reader_pipe_id);
1808
1809 break;
1810 }
1811#endif /* #ifdef TYPE_ISO15693 */
1812#ifdef ENABLE_P2P
1813 case phHal_eNfcIP1_Target:
1814 {
1815 /* Get the Reader A Pipe ID */
1816 status = phHciNfc_Initiator_Get_PipeID
1817 (psHciContext, &reader_pipe_id);
1818
1819 break;
1820 }
1821#endif
1822 default:
1823 {
1824 status = PHNFCSTVAL(CID_NFC_HCI,
1825 NFCSTATUS_FEATURE_NOT_SUPPORTED);
1826 break;
1827 }
1828
1829 } /* End of the tag_type Switch */
1830 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
1831 if( (NFCSTATUS_SUCCESS == status)
1832 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1833 && ( NULL != p_pipe_info ) )
1834 {
1835 if (TRUE == rls_param)
1836 {
1837 p_pipe_info->param_info = &rls_param;
1838 p_pipe_info->param_length = sizeof(rls_param);
1839 }
1840 status = phHciNfc_Send_RFReader_Event ( psHciContext, pHwRef,
1841 reader_pipe_id,(uint8_t) NXP_EVT_RELEASE_TARGET );
1842 }
1843 }
1844
1845 return status;
1846}
1847
1848
1849/*!
1850 * \brief Exchanges the data to/from the selected tags via RF Reader Gates.
1851 *
1852 * This function Exchanges the data to/from the selected tags
1853 * via RF Reader Gates. This function uses the RF Reader gate based on the
1854 * type of the selected tag and the type of the Reader gate specified.
1855 */
1856
1857
1858NFCSTATUS
1859phHciNfc_ReaderMgmt_Exchange_Data(
1860 phHciNfc_sContext_t *psHciContext,
1861 void *pHwRef,
1862 phHciNfc_XchgInfo_t *p_xchg_info
1863 )
1864{
1865 NFCSTATUS status = NFCSTATUS_SUCCESS;
1866 phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
1867 uint8_t reader_pipe_id = (uint8_t) HCI_UNKNOWN_PIPE_ID;
1868 phHal_eRemDevType_t target_type = phHal_eUnknown_DevType;
1869
1870 if( (NULL == psHciContext) || (NULL == pHwRef) )
1871 {
1872 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1873 }
1874 else if (NULL == psHciContext->p_xchg_info)
1875 {
1876 status = PHNFCSTVAL(CID_NFC_HCI,
1877 NFCSTATUS_INVALID_HCI_INFORMATION);
1878
1879 }
1880 else
1881 {
1882 switch (psHciContext->host_rf_type)
1883 {
1884 case phHal_eISO14443_A_PCD:
1885 {
1886 /* Get the Reader A Pipe ID */
1887 status = phHciNfc_ReaderA_Get_PipeID
1888 (psHciContext, &reader_pipe_id);
1889
1890 if( (NFCSTATUS_SUCCESS == status)
1891 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1892 )
1893 {
1894 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
1895 p_pipe_info->param_info = p_xchg_info->tx_buffer;
1896 p_pipe_info->param_length = p_xchg_info->tx_length;
1897 target_type = psHciContext->p_target_info->RemDevType;
1898 switch (target_type)
1899 {
1900 case phHal_eMifare_PICC:
1901 case phHal_eISO14443_3A_PICC:
1902 {
1903 if ((uint8_t)phHal_eMifareRaw ==
1904 p_xchg_info->params.tag_info.cmd_type)
1905 {
1906 status = phHciNfc_Send_ReaderA_Command(
1907 psHciContext, pHwRef
1908 ,reader_pipe_id, NXP_MIFARE_RAW );
1909 }
1910 else
1911 {
1912 status = phHciNfc_Send_ReaderA_Command(
1913 psHciContext, pHwRef,
1914 reader_pipe_id, NXP_MIFARE_CMD );
1915 }
1916 break;
1917 }
1918 case phHal_eISO14443_A_PICC:
1919 case phHal_eISO14443_4A_PICC:
1920 {
1921 status = phHciNfc_Send_RFReader_Command(
1922 psHciContext, pHwRef,
1923 reader_pipe_id, WR_XCHGDATA );
1924 break;
1925 }
1926 default:
1927 {
1928 status = PHNFCSTVAL(CID_NFC_HCI,
1929 NFCSTATUS_FEATURE_NOT_SUPPORTED);
1930 break;
1931 }
1932 } /* End of the tag_type Switch */
1933 } /* End of Pipe ID Check */
1934 break;
1935 }
1936#ifdef TYPE_B
1937 case phHal_eISO14443_B_PCD:
1938 {
1939 /* Get the Reader B Pipe ID */
1940 status = phHciNfc_ReaderB_Get_PipeID
1941 (psHciContext, &reader_pipe_id);
1942
1943 if( (NFCSTATUS_SUCCESS == status)
1944 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1945 )
1946 {
1947 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
1948 p_pipe_info->param_info = p_xchg_info->tx_buffer;
1949 p_pipe_info->param_length = p_xchg_info->tx_length;
1950 status = phHciNfc_Send_RFReader_Command(
1951 psHciContext, pHwRef,
1952 reader_pipe_id, WR_XCHGDATA );
1953 }
1954 break;
1955 }
1956#endif /* #ifdef TYPE_B */
1957#ifdef TYPE_FELICA
1958 case phHal_eFelica_PCD:
1959 {
1960 /* Get the Felica Reader Pipe ID */
1961 status = phHciNfc_Felica_Get_PipeID
1962 (psHciContext, &reader_pipe_id);
1963
1964 if( (NFCSTATUS_SUCCESS == status)
1965 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1966 )
1967 {
1968 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
1969 p_pipe_info->param_info = p_xchg_info->tx_buffer;
1970 p_pipe_info->param_length = p_xchg_info->tx_length;
1971 if ((uint8_t)phHal_eFelica_Raw ==
1972 p_xchg_info->params.tag_info.cmd_type)
1973 {
1974 status = phHciNfc_Send_Felica_Command(
1975 psHciContext, pHwRef
1976 ,reader_pipe_id, NXP_FELICA_RAW );
1977 }
1978 else
1979 {
1980 status = phHciNfc_Send_Felica_Command(
1981 psHciContext, pHwRef,
1982 reader_pipe_id, NXP_FELICA_CMD );
1983 }
1984 }
1985 break;
1986 }
1987#endif /* #ifdef TYPE_FELICA */
1988#if defined(TYPE_ISO15693)
1989 case phHal_eISO15693_PCD:
1990 {
1991 /* Get the ISO15693 Reader Pipe ID */
1992 status = phHciNfc_ISO15693_Get_PipeID
1993 (psHciContext, &reader_pipe_id);
1994
1995 if( (NFCSTATUS_SUCCESS == status)
1996 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
1997 )
1998 {
1999 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
2000 p_pipe_info->param_info = p_xchg_info->tx_buffer;
2001 p_pipe_info->param_length = p_xchg_info->tx_length;
2002 if (((uint8_t)phHal_eIso15693_Cmd ==
2003 p_xchg_info->params.tag_info.cmd_type)
2004#if defined(SUPPORT_ISO15693_RAW)
2005 || ((uint8_t) phHal_eIso15693_Raw ==
2006 p_xchg_info->params.tag_info.cmd_type)
2007#endif
2008 )
2009 {
2010 status = phHciNfc_Send_ISO15693_Command(
2011 psHciContext, pHwRef
2012 ,reader_pipe_id, NXP_ISO15693_CMD );
2013 }
2014 else
2015 {
2016 status = PHNFCSTVAL(CID_NFC_HCI,
2017 NFCSTATUS_INVALID_PARAMETER);
2018 }
2019 }
2020 break;
2021 }
2022#endif
2023#ifdef TYPE_JEWEL
2024 case phHal_eJewel_PCD:
2025 {
2026 /* Get the Jewel Reader Pipe ID */
2027 status = phHciNfc_Jewel_Get_PipeID
2028 (psHciContext, &reader_pipe_id);
2029
2030 if( (NFCSTATUS_SUCCESS == status)
2031 && (reader_pipe_id != HCI_UNKNOWN_PIPE_ID )
2032 )
2033 {
2034 uint8_t transact_type = 0;
2035 p_pipe_info = psHciContext->p_pipe_list[reader_pipe_id];
2036 p_pipe_info->param_info = p_xchg_info->tx_buffer;
2037 p_pipe_info->param_length = p_xchg_info->tx_length;
2038 switch(p_xchg_info->params.tag_info.cmd_type)
2039 {
2040 case phHal_eJewel_Raw:
2041 {
2042 transact_type = NXP_JEWEL_RAW;
2043 break;
2044 }
2045 case phHal_eJewel_Invalid:
2046 default:
2047 {
2048 status = PHNFCSTVAL(CID_NFC_HCI,
2049 NFCSTATUS_INVALID_PARAMETER);
2050 break;
2051 }
2052 }
2053 if(0 != transact_type)
2054 {
2055 status = phHciNfc_Send_Jewel_Command(
2056 psHciContext, pHwRef,
2057 reader_pipe_id, transact_type );
2058 }
2059 }
2060 break;
2061 }
2062#endif /* #ifdef TYPE_JEWEL */
2063 default:
2064 {
2065 status = PHNFCSTVAL(CID_NFC_HCI,
2066 NFCSTATUS_FEATURE_NOT_SUPPORTED);
2067 break;
2068 }
2069 }/* End of Reader Type Switch */
2070 }
2071
2072 return status;
2073}
2074
2075
2076
2077/*!
2078 * \brief Releases the resources allocated the RF Reader Management.
2079 *
2080 * This function Releases the resources allocated the RF Reader Management.
2081 */
2082
2083NFCSTATUS
2084phHciNfc_ReaderMgmt_Release(
2085 phHciNfc_sContext_t *psHciContext,
2086 void *pHwRef
2087 )
2088{
2089 NFCSTATUS status = NFCSTATUS_SUCCESS;
2090 phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
2091 phHciNfc_ReaderMgmt_Info_t *p_reader_mgmt_info=NULL;
2092
2093 if( (NULL == psHciContext) || (NULL == pHwRef) )
2094 {
2095 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
2096 }
2097 else
2098 {
2099 if( NULL != psHciContext->p_reader_mgmt_info )
2100 {
2101 p_reader_mgmt_info = (phHciNfc_ReaderMgmt_Info_t *)
2102 psHciContext->p_reader_mgmt_info ;
2103 switch(p_reader_mgmt_info->rf_gate_cur_seq)
2104 {
2105 /* Reader A pipe close sequence */
2106 case READERA_PIPE_CLOSE:
2107 {
2108 p_pipe_info = ((phHciNfc_ReaderA_Info_t *)
2109 psHciContext->p_reader_a_info)->p_pipe_info;
2110
2111 status = phHciNfc_Close_Pipe( psHciContext,
2112 pHwRef, p_pipe_info );
2113 if(status == NFCSTATUS_SUCCESS)
2114 {
2115 p_reader_mgmt_info->rf_gate_next_seq =
2116 READERB_PIPE_CLOSE;
2117 /* status = NFCSTATUS_PENDING; */
2118 }
2119 break;
2120 }
2121#ifdef TYPE_B
2122 /* Reader B pipe close sequence */
2123 case READERB_PIPE_CLOSE:
2124 {
2125 p_pipe_info = ((phHciNfc_ReaderB_Info_t *)
2126 psHciContext->p_reader_b_info)->p_pipe_info;
2127
2128 status = phHciNfc_Close_Pipe( psHciContext,
2129 pHwRef, p_pipe_info );
2130 if(status == NFCSTATUS_SUCCESS)
2131 {
2132 p_reader_mgmt_info->rf_gate_next_seq =
2133 FELICA_PROP_PIPE_CLOSE;
2134 status = NFCSTATUS_PENDING;
2135 }
2136 break;
2137 }
2138#endif /* #ifdef TYPE_B */
2139#ifdef TYPE_FELICA
2140 /* Felica Reader pipe close sequence */
2141 case FELICA_PROP_PIPE_CLOSE:
2142 {
2143 p_pipe_info = ((phHciNfc_Felica_Info_t *)
2144 psHciContext->p_felica_info)->p_pipe_info;
2145
2146 status = phHciNfc_Close_Pipe( psHciContext,
2147 pHwRef, p_pipe_info );
2148 if(status == NFCSTATUS_SUCCESS)
2149 {
2150 p_reader_mgmt_info->rf_gate_next_seq =
2151 NFCIP1_INITIATOR_PIPE_CLOSE;
2152 /* status = NFCSTATUS_PENDING; */
2153 }
2154 break;
2155 }
2156#endif /* #ifdef TYPE_FELICA */
2157#ifdef ENABLE_P2P
2158 /* NFC-IP1 Initiator pipe Close sequence */
2159 case NFCIP1_INITIATOR_PIPE_CLOSE:
2160 {
2161 p_pipe_info =
2162 ((phHciNfc_NfcIP_Info_t *)psHciContext->
2163 p_nfcip_info)->p_init_pipe_info;
2164 if(NULL == p_pipe_info )
2165 {
2166 status = PHNFCSTVAL(CID_NFC_HCI,
2167 NFCSTATUS_INVALID_HCI_SEQUENCE);
2168 }
2169 else
2170 {
2171 status = phHciNfc_Open_Pipe( psHciContext,
2172 pHwRef, p_pipe_info );
2173 if(status == NFCSTATUS_SUCCESS)
2174 {
2175 p_reader_mgmt_info->rf_gate_next_seq = READERA_PIPE_CLOSE;
2176 status = NFCSTATUS_PENDING;
2177 }
2178 }
2179 break;
2180 }
2181#endif /* #ifdef ENABLE_P2P */
2182 default:
2183 {
2184 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_SEQUENCE);
2185 break;
2186 }
2187
2188 }/* End of the Sequence Switch */
2189
2190 }/* End of the Reader Info Memory Check */
2191
2192 } /* End of Null Context Check */
2193
2194 return status;
2195}
2196
2197
2198/*!
2199 * \brief Sends the RF Reader HCI Events to the connected reader device.
2200 *
2201 * This function Sends the RF Reader HCI Event frames in the HCP packet format to the
2202 * connected reader device.
2203 */
2204
2205 NFCSTATUS
2206 phHciNfc_Send_RFReader_Event (
2207 phHciNfc_sContext_t *psHciContext,
2208 void *pHwRef,
2209 uint8_t pipe_id,
2210 uint8_t event
2211 )
2212 {
2213 phHciNfc_HCP_Packet_t *hcp_packet = NULL;
2214 phHciNfc_HCP_Message_t *hcp_message = NULL;
2215 phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
2216 uint8_t length = 0;
2217 uint8_t i = 0;
2218 NFCSTATUS status = NFCSTATUS_SUCCESS;
2219
2220 if( (NULL == psHciContext)
2221 || ( pipe_id > PHHCINFC_MAX_PIPE)
2222 ||(NULL == psHciContext->p_pipe_list[pipe_id])
2223 )
2224 {
2225 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
2226 HCI_DEBUG("%s: Invalid Arguments passed \n",
2227 "phHciNfc_Send_RFReader_Event");
2228 }
2229 else
2230 {
2231 p_pipe_info = (phHciNfc_Pipe_Info_t *)
2232 psHciContext->p_pipe_list[pipe_id];
2233 psHciContext->tx_total = 0 ;
2234 length += HCP_HEADER_LEN ;
2235 switch( event )
2236 {
2237 case EVT_READER_REQUESTED:
2238 case EVT_END_OPERATION:
2239 {
2240
2241 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
2242 /* Construct the HCP Frame */
2243 phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT,
2244 (uint8_t) pipe_id, HCP_MSG_TYPE_EVENT, event);
2245 break;
2246 }
2247 case NXP_EVT_RELEASE_TARGET:
2248 {
2249 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
2250 /* Construct the HCP Frame */
2251 phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT,
2252 (uint8_t) pipe_id, HCP_MSG_TYPE_EVENT, event);
2253 hcp_message = &(hcp_packet->msg.message);
2254 phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload,
2255 i, p_pipe_info->param_info,
2256 p_pipe_info->param_length);
Jan Brands1c7419c2010-11-27 17:16:31 +0100[diff] [blame]2257 length =(uint16_t)(length + i + p_pipe_info->param_length);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2258 break;
2259 }
2260 default:
2261 {
2262 status = PHNFCSTVAL( CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED );
2263 HCI_DEBUG("%s: Statement Should Not Occur \n",
2264 "phHciNfc_Send_RFReader_Event");
2265 break;
2266 }
2267 }
2268 if( NFCSTATUS_SUCCESS == status )
2269 {
2270 p_pipe_info->sent_msg_type = HCP_MSG_TYPE_EVENT ;
2271 p_pipe_info->prev_msg = event ;
2272 psHciContext->tx_total = length;
2273
2274 /* Send the Constructed HCP packet to the lower layer */
2275 status = phHciNfc_Send_HCP( psHciContext, pHwRef );
2276 p_pipe_info->prev_status = NFCSTATUS_PENDING;
2277 }
2278 }
2279
2280 return status;
2281}
2282
2283/*!
2284 * \brief Sends the RF Reader HCI Additonal Commands to the connected
2285 * reader device.
2286 *
2287 * This function Sends the RF Reader HCI Command frames in the HCP packet
2288 * format to the connected reader device.
2289 */
2290
2291 NFCSTATUS
2292 phHciNfc_Send_RFReader_Command (
2293 phHciNfc_sContext_t *psHciContext,
2294 void *pHwRef,
2295 uint8_t pipe_id,
2296 uint8_t cmd
2297 )
2298 {
2299 phHciNfc_HCP_Packet_t *hcp_packet = NULL;
2300 phHciNfc_HCP_Message_t *hcp_message = NULL;
2301 phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
2302 uint8_t i = 0;
Jan Brands1c7419c2010-11-27 17:16:31 +0100[diff] [blame]2303 uint16_t length=0;
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2304 NFCSTATUS status = NFCSTATUS_SUCCESS;
2305
2306 if( (NULL == psHciContext)
2307 || ( pipe_id > PHHCINFC_MAX_PIPE)
2308 ||(NULL == psHciContext->p_pipe_list[pipe_id])
2309 )
2310 {
2311 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
2312 HCI_DEBUG("%s: Invalid Arguments passed \n",
2313 "phHciNfc_Send_RFReader_Command");
2314 }
2315 else
2316 {
2317 p_pipe_info = (phHciNfc_Pipe_Info_t *)
2318 psHciContext->p_pipe_list[pipe_id];
2319 psHciContext->tx_total = 0 ;
2320 length += HCP_HEADER_LEN ;
2321 switch( cmd )
2322 {
2323 case WR_XCHGDATA:
2324 {
2325
2326 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
2327 /* Construct the HCP Frame */
2328 phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT,
2329 (uint8_t) pipe_id, HCP_MSG_TYPE_COMMAND, cmd);
2330 hcp_message = &(hcp_packet->msg.message);
2331 /* Frame Wait Timeout */
Martijn Coenen72854a22011-01-12 20:44:37 +0100[diff] [blame]2332 hcp_message->payload[i++] = nxp_nfc_isoxchg_timeout ;
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2333 phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload,
2334 i, p_pipe_info->param_info,
2335 p_pipe_info->param_length);
Jan Brands1c7419c2010-11-27 17:16:31 +0100[diff] [blame]2336 length =(uint16_t)(length + i + p_pipe_info->param_length);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2337 break;
2338 }
2339 case NXP_WR_PRESCHECK:
2340 case NXP_WR_ACTIVATE_NEXT:
2341 {
2342
2343 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
2344 /* Construct the HCP Frame */
2345 phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT,
2346 (uint8_t) pipe_id, HCP_MSG_TYPE_COMMAND, cmd);
2347 break;
2348 }
2349 case NXP_WR_DISPATCH_TO_UICC:
2350 case NXP_WR_ACTIVATE_ID:
2351 {
2352
2353 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
2354 /* Construct the HCP Frame */
2355 phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT,
2356 (uint8_t) pipe_id, HCP_MSG_TYPE_COMMAND, cmd);
2357 hcp_message = &(hcp_packet->msg.message);
2358 /* UID of the Card */
2359 phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload,
2360 i, p_pipe_info->param_info,
2361 p_pipe_info->param_length);
Jan Brands1c7419c2010-11-27 17:16:31 +0100[diff] [blame]2362 length =(uint16_t)(length + i + p_pipe_info->param_length);
Nick Pelly5d9927b2010-09-23 12:47:58 -0700[diff] [blame]2363 break;
2364 }
2365 default:
2366 {
2367 status = PHNFCSTVAL( CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED );
2368 HCI_DEBUG("%s: Statement Should Not Occur \n",
2369 "phHciNfc_Send_RFReader_Command");
2370 break;
2371 }
2372 }
2373 if( NFCSTATUS_SUCCESS == status )
2374 {
2375 p_pipe_info->sent_msg_type = HCP_MSG_TYPE_COMMAND;
2376 p_pipe_info->prev_msg = cmd;
2377 psHciContext->tx_total = length;
2378 psHciContext->response_pending = TRUE ;
2379
2380 /* Send the Constructed HCP packet to the lower layer */
2381 status = phHciNfc_Send_HCP( psHciContext, pHwRef );
2382 p_pipe_info->prev_status = NFCSTATUS_PENDING;
2383 }
2384 }
2385
2386 return status;
2387}
2388
2389
2390