Gitiles
Code Review Sign In
review.blissroms.org / platform_external_libnfc-nxp / refs/heads/o8.0-rebase / . / src / phHciNfc_RFReaderB.c
blob: 4ddd4bf37ca41b0bc68836a2f873833b8dd89db9 [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_RFReaderB.c *
22* \brief HCI Reader B Management Routines. *
23* *
24* *
25* Project: NFC-FRI-1.1 *
26* *
27* $Date: Mon Aug 17 15:17:07 2009 $ *
28* $Author: ing04880 $ *
29* $Revision: 1.7 $ *
30* $Aliases: NFC_FRI1.1_WK934_R31_1,NFC_FRI1.1_WK941_PREP1,NFC_FRI1.1_WK941_PREP2,NFC_FRI1.1_WK941_1,NFC_FRI1.1_WK943_R32_1,NFC_FRI1.1_WK949_PREP1,NFC_FRI1.1_WK943_R32_10,NFC_FRI1.1_WK943_R32_13,NFC_FRI1.1_WK943_R32_14,NFC_FRI1.1_WK1007_R33_1,NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $
31* *
32* =========================================================================== *
33*/
34
35/*
36***************************** Header File Inclusion ****************************
37*/
38#include <phNfcCompId.h>
39#include <phHciNfc_Pipe.h>
40#include <phHciNfc_RFReader.h>
41#include <phOsalNfc.h>
42
43#if defined (TYPE_B)
44#include <phHciNfc_RFReaderB.h>
45/*
46****************************** Macro Definitions *******************************
47*/
48
49#define RDR_B_SINGLE_TAG_FOUND 0x00U
50#define RDR_B_MULTIPLE_TAGS_FOUND 0x03U
51/* Commands exposed to the upper layer */
52#define NXP_WRA_CONTINUE_ACTIVATION 0x12U
53
54#define RDR_B_PUPI_INDEX 0x03U
55#define RDR_B_APP_DATA_INDEX 0x04U
56#define RDR_B_AFI_INDEX 0x02U
57#define RDR_B_HIGHER_LAYER_RESP_INDEX 0x01U
58#define RDR_B_HIGHER_LAYER_DATA_INDEX 0x05U
59
60
61/*
62*************************** Structure and Enumeration ***************************
63*/
64
65
66/*
67*************************** Static Function Declaration **************************
68*/
69
70static
71NFCSTATUS
72phHciNfc_Recv_ReaderB_Response(
73 void *psContext,
74 void *pHwRef,
75 uint8_t *pResponse,
76#ifdef ONE_BYTE_LEN
77 uint8_t length
78#else
79 uint16_t length
80#endif
81 );
82
83static
84NFCSTATUS
85phHciNfc_Recv_ReaderB_Event(
86 void *psContext,
87 void *pHwRef,
88 uint8_t *pEvent,
89#ifdef ONE_BYTE_LEN
90 uint8_t length
91#else
92 uint16_t length
93#endif
94 );
95
96static
97NFCSTATUS
98phHciNfc_ReaderB_InfoUpdate(
99 phHciNfc_sContext_t *psHciContext,
100 uint8_t index,
101 uint8_t *reg_value,
102 uint8_t reg_length
103 );
104
105static
106NFCSTATUS
107phHciNfc_Recv_Iso_B_Packet(
108 phHciNfc_sContext_t *psHciContext,
109 uint8_t *pResponse,
110#ifdef ONE_BYTE_LEN
111 uint8_t length
112#else
113 uint16_t length
114#endif
115 );
116/*
117*************************** Function Definitions ***************************
118*/
119
120NFCSTATUS
121phHciNfc_ReaderB_Get_PipeID(
122 phHciNfc_sContext_t *psHciContext,
123 uint8_t *ppipe_id
124 )
125{
126 NFCSTATUS status = NFCSTATUS_SUCCESS;
127
128 if( (NULL != psHciContext)
129 && ( NULL != ppipe_id )
130 && ( NULL != psHciContext->p_reader_b_info )
131 )
132 {
133 phHciNfc_ReaderB_Info_t *p_rdr_b_info=NULL;
134 p_rdr_b_info = (phHciNfc_ReaderB_Info_t *)
135 psHciContext->p_reader_b_info ;
136 *ppipe_id = p_rdr_b_info->pipe_id ;
137 }
138 else
139 {
140 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
141 }
142 return status;
143}
144
145NFCSTATUS
146phHciNfc_ReaderB_Init_Resources(
147 phHciNfc_sContext_t *psHciContext
148 )
149{
150 NFCSTATUS status = NFCSTATUS_SUCCESS;
151 phHciNfc_ReaderB_Info_t *p_rdr_b_info=NULL;
152 if( NULL == psHciContext )
153 {
154 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
155 }
156 else
157 {
158 if(
159 ( NULL == psHciContext->p_reader_b_info ) &&
160 (phHciNfc_Allocate_Resource((void **)(&p_rdr_b_info),
161 sizeof(phHciNfc_ReaderB_Info_t))== NFCSTATUS_SUCCESS)
162 )
163 {
164 psHciContext->p_reader_b_info = p_rdr_b_info;
165 p_rdr_b_info->current_seq = RDR_B_INVALID_SEQ;
166 p_rdr_b_info->next_seq = RDR_B_INVALID_SEQ;
167 p_rdr_b_info->pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
168 }
169 else
170 {
171 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
172 }
173
174 }
175 return status;
176}
177
178NFCSTATUS
179phHciNfc_ReaderB_Update_Info(
180 phHciNfc_sContext_t *psHciContext,
181 uint8_t infotype,
182 void *rdr_b_info
183 )
184{
185 NFCSTATUS status = NFCSTATUS_SUCCESS;
186
187 if (NULL == psHciContext)
188 {
189 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
190 }
191 else if(NULL == psHciContext->p_reader_b_info)
192 {
193 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
194 }
195 else
196 {
197 phHciNfc_ReaderB_Info_t *ps_rdr_b_info=NULL;
198 ps_rdr_b_info = (phHciNfc_ReaderB_Info_t *)
199 psHciContext->p_reader_b_info ;
200
201 switch(infotype)
202 {
203 case HCI_READER_B_ENABLE:
204 {
205 if(NULL != rdr_b_info)
206 {
207 ps_rdr_b_info->enable_rdr_b_gate =
208 *((uint8_t *)rdr_b_info);
209 }
210 break;
211 }
212 case HCI_READER_B_INFO_SEQ:
213 {
214 ps_rdr_b_info->current_seq = RDR_B_PUPI;
215 ps_rdr_b_info->next_seq = RDR_B_PUPI;
216 break;
217 }
218 default:
219 {
220 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
221 break;
222 }
223 }
224 }
225 return status;
226}
227
228
229NFCSTATUS
230phHciNfc_ReaderB_Update_PipeInfo(
231 phHciNfc_sContext_t *psHciContext,
232 uint8_t pipeID,
233 phHciNfc_Pipe_Info_t *pPipeInfo
234 )
235{
236 NFCSTATUS status = NFCSTATUS_SUCCESS;
237
238 if( NULL == psHciContext )
239 {
240 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
241 }
242 else if(NULL == psHciContext->p_reader_b_info)
243 {
244 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
245 }
246 else
247 {
248 phHciNfc_ReaderB_Info_t *p_rdr_b_info=NULL;
249 p_rdr_b_info = (phHciNfc_ReaderB_Info_t *)
250 psHciContext->p_reader_b_info ;
251 /* Update the pipe_id of the reader B Gate obtained from the HCI Response */
252 p_rdr_b_info->pipe_id = pipeID;
253 p_rdr_b_info->p_pipe_info = pPipeInfo;
254 /* Update the Response Receive routine of the reader B Gate */
255 pPipeInfo->recv_resp = &phHciNfc_Recv_ReaderB_Response;
256 /* Update the event Receive routine of the reader B Gate */
257 pPipeInfo->recv_event = &phHciNfc_Recv_ReaderB_Event;
258 }
259
260 return status;
261}
262
263NFCSTATUS
264phHciNfc_ReaderB_Info_Sequence (
265 void *psHciHandle,
266 void *pHwRef
267 )
268{
269 NFCSTATUS status = NFCSTATUS_SUCCESS;
270 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
271 if( (NULL == psHciContext)
272 || (NULL == pHwRef)
273 )
274 {
275 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
276 }
277 else if((NULL == psHciContext->p_reader_b_info) ||
278 (HCI_READER_B_ENABLE !=
279 ((phHciNfc_ReaderB_Info_t *)(psHciContext->p_reader_b_info))->
280 enable_rdr_b_gate))
281 {
282 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
283 }
284 else
285 {
286 phHciNfc_ReaderB_Info_t *p_rdr_b_info=NULL;
287 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
288 uint8_t pipeid = 0;
289
290 p_rdr_b_info = (phHciNfc_ReaderB_Info_t *)
291 psHciContext->p_reader_b_info ;
292 p_pipe_info = p_rdr_b_info->p_pipe_info;
293 if(NULL == p_pipe_info )
294 {
295 status = PHNFCSTVAL(CID_NFC_HCI,
296 NFCSTATUS_INVALID_HCI_SEQUENCE);
297 }
298 else
299 {
300 switch(p_rdr_b_info->current_seq)
301 {
302 case RDR_B_PUPI:
303 {
304 p_pipe_info->reg_index = RDR_B_PUPI_INDEX;
305 pipeid = p_rdr_b_info->pipe_id ;
306 /* Fill the data buffer and send the command to the
307 device */
308 status =
309 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
310 pipeid, (uint8_t)ANY_GET_PARAMETER);
311 if(NFCSTATUS_PENDING == status )
312 {
313 p_rdr_b_info->next_seq = RDR_B_APP_DATA;
314 }
315 break;
316 }
317 case RDR_B_APP_DATA:
318 {
319 p_pipe_info->reg_index = RDR_B_APP_DATA_INDEX;
320 pipeid = p_rdr_b_info->pipe_id ;
321 /* Fill the data buffer and send the command to the
322 device */
323 status =
324 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
325 pipeid, (uint8_t)ANY_GET_PARAMETER);
326 if(NFCSTATUS_PENDING == status )
327 {
328 p_rdr_b_info->next_seq = RDR_B_AFI;
329 }
330 break;
331 }
332 case RDR_B_AFI:
333 {
334 /* RW to the registry */
335 p_pipe_info->reg_index = RDR_B_AFI_INDEX;
336 pipeid = p_rdr_b_info->pipe_id ;
337 /* Fill the data buffer and send the command to the
338 device */
339 status =
340 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
341 pipeid, (uint8_t)ANY_GET_PARAMETER);
342 if(NFCSTATUS_PENDING == status )
343 {
344 p_rdr_b_info->next_seq = RDR_B_HIGHER_LAYER_RESP;
345 }
346 break;
347 }
348
349 case RDR_B_HIGHER_LAYER_RESP:
350 {
351 p_pipe_info->reg_index = RDR_B_HIGHER_LAYER_RESP_INDEX;
352 pipeid = p_rdr_b_info->pipe_id ;
353 /* Fill the data buffer and send the command to the
354 device */
355 status =
356 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
357 pipeid, (uint8_t)ANY_GET_PARAMETER);
358 if(NFCSTATUS_PENDING == status )
359 {
360 p_rdr_b_info->next_seq = RDR_B_HIGHER_LAYER_DATA;
361 }
362 break;
363 }
364
365 case RDR_B_HIGHER_LAYER_DATA:
366 {
367 /* RW to the registry */
368 p_pipe_info->reg_index = RDR_B_HIGHER_LAYER_DATA_INDEX;
369 pipeid = p_rdr_b_info->pipe_id ;
370 /* Fill the data buffer and send the command to the
371 device */
372 status =
373 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
374 pipeid, (uint8_t)ANY_GET_PARAMETER);
375 if(NFCSTATUS_PENDING == status )
376 {
377 p_rdr_b_info->next_seq = RDR_B_END_SEQUENCE;
378 }
379 break;
380 }
381 case RDR_B_END_SEQUENCE:
382 {
383 phNfc_sCompletionInfo_t CompInfo;
384 if (RDR_B_MULTIPLE_TAGS_FOUND ==
385 p_rdr_b_info->multiple_tgts_found)
386 {
387 CompInfo.status = NFCSTATUS_MULTIPLE_TAGS;
388 }
389 else
390 {
391 CompInfo.status = NFCSTATUS_SUCCESS;
392 }
393
394 CompInfo.info = &(p_rdr_b_info->reader_b_info);
395
396 p_rdr_b_info->reader_b_info.RemDevType = phHal_eISO14443_B_PICC;
397 p_rdr_b_info->current_seq = RDR_B_PUPI;
398 p_rdr_b_info->next_seq = RDR_B_PUPI;
399 status = NFCSTATUS_SUCCESS;
400 /* Notify to the upper layer */
401 phHciNfc_Tag_Notify(psHciContext,
402 pHwRef,
403 NFC_NOTIFY_TARGET_DISCOVERED,
404 &CompInfo);
405 break;
406 }
407 default:
408 {
409 status = PHNFCSTVAL(CID_NFC_HCI,
410 NFCSTATUS_INVALID_HCI_RESPONSE);
411 break;
412 }
413 }
414 }
415 }
416 return status;
417}
418
419static
420NFCSTATUS
421phHciNfc_Recv_ReaderB_Response(
422 void *psContext,
423 void *pHwRef,
424 uint8_t *pResponse,
425#ifdef ONE_BYTE_LEN
426 uint8_t length
427#else
428 uint16_t length
429#endif
430 )
431{
432 NFCSTATUS status = NFCSTATUS_SUCCESS;
433 phHciNfc_sContext_t *psHciContext =
434 (phHciNfc_sContext_t *)psContext ;
435
436 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse)
437 || (length == 0))
438 {
439 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
440 }
441 else if(NULL == psHciContext->p_reader_b_info)
442 {
443 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
444 }
445 else
446 {
447 phHciNfc_ReaderB_Info_t *p_rdr_b_info=NULL;
448 uint8_t prev_cmd = ANY_GET_PARAMETER;
449
450 p_rdr_b_info = (phHciNfc_ReaderB_Info_t *)
451 psHciContext->p_reader_b_info ;
452 if( NULL == p_rdr_b_info->p_pipe_info)
453 {
454 status = PHNFCSTVAL(CID_NFC_HCI,
455 NFCSTATUS_INVALID_HCI_SEQUENCE);
456 }
457 else
458 {
459 prev_cmd = p_rdr_b_info->p_pipe_info->prev_msg ;
460 switch(prev_cmd)
461 {
462 case ANY_GET_PARAMETER:
463 {
464 status = phHciNfc_ReaderB_InfoUpdate(psHciContext,
465 p_rdr_b_info->p_pipe_info->reg_index,
466 &pResponse[HCP_HEADER_LEN],
467 (uint8_t)(length - HCP_HEADER_LEN));
468 break;
469 }
470 case ANY_SET_PARAMETER:
471 {
472 HCI_PRINT("Reader B Parameter Set \n");
473 status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext,
474 UPDATE_SEQ);
475 p_rdr_b_info->next_seq = RDR_B_PUPI;
476 break;
477 }
478 case ANY_OPEN_PIPE:
479 {
480 HCI_PRINT("Reader B open pipe complete\n");
481 status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext,
482 UPDATE_SEQ);
483 p_rdr_b_info->next_seq = RDR_B_PUPI;
484 break;
485 }
486 case ANY_CLOSE_PIPE:
487 {
488 HCI_PRINT("Reader B close pipe complete\n");
489 status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext,
490 UPDATE_SEQ);
491 break;
492 }
493 case NXP_WRA_CONTINUE_ACTIVATION:
494 case NXP_WR_ACTIVATE_ID:
495 {
496 HCI_PRINT("Reader B continue activation or ");
497 HCI_PRINT("reactivation completed \n");
498 status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext,
499 UPDATE_SEQ);
500 break;
501 }
502 case WR_XCHGDATA:
503 {
504 if (length >= HCP_HEADER_LEN)
505 {
506 uint8_t i = 1;
507 HCI_PRINT("ISO 14443-4B received \n");
508 /* Copy buffer to the receive buffer */
509 phHciNfc_Append_HCPFrame(psHciContext->recv_buffer,
510 0, pResponse, length);
511 psHciContext->rx_total = (length - i);
512 status = phHciNfc_Recv_Iso_B_Packet(psHciContext,
513 &pResponse[HCP_HEADER_LEN],
514 (length - HCP_HEADER_LEN));
515 }
516 else
517 {
518 status = PHNFCSTVAL(CID_NFC_HCI,
519 NFCSTATUS_INVALID_HCI_RESPONSE);
520 }
521 break;
522 }
523 case NXP_WR_PRESCHECK:
524 {
525 HCI_PRINT("Presence check completed \n");
526 break;
527 }
528 case NXP_WR_ACTIVATE_NEXT:
529 {
530 if (length > HCP_HEADER_LEN)
531 {
532 if (RDR_B_MULTIPLE_TAGS_FOUND == pResponse[HCP_HEADER_LEN])
533 {
534 p_rdr_b_info->multiple_tgts_found =
535 RDR_B_MULTIPLE_TAGS_FOUND;
536 }
537 else
538 {
539 p_rdr_b_info->multiple_tgts_found = FALSE;
540 }
541 HCI_PRINT("Activate next completed \n");
542 }
543 else
544 {
545 status = PHNFCSTVAL(CID_NFC_HCI,
546 NFCSTATUS_INVALID_HCI_RESPONSE);
547 }
548 break;
549 }
550 case NXP_WR_DISPATCH_TO_UICC:
551 {
552 switch(length)
553 {
554 case HCP_HEADER_LEN:
555 {
556 /* Error code field is optional, if no error
557 code field in the response, then the command
558 is successfully completed */
559 p_rdr_b_info->uicc_activation =
560 UICC_CARD_ACTIVATION_SUCCESS;
561 break;
562 }
563 case (HCP_HEADER_LEN + 1):
564 {
565 p_rdr_b_info->uicc_activation =
566 pResponse[HCP_HEADER_LEN];
567 break;
568 } /* End of case (HCP_HEADER_LEN + index) */
569 default:
570 {
571 status = PHNFCSTVAL(CID_NFC_HCI,
572 NFCSTATUS_INVALID_HCI_RESPONSE);
573 break;
574 }
575 } /* End of switch(length) */
576 if (NFCSTATUS_SUCCESS == status)
577 {
578 status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext,
579 UPDATE_SEQ);
580 }
581 break;
582 }
583 default:
584 {
585 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
586 break;
587 }
588 }
589 if( NFCSTATUS_SUCCESS == status )
590 {
591 p_rdr_b_info->p_pipe_info->prev_status = NFCSTATUS_SUCCESS;
592 p_rdr_b_info->current_seq = p_rdr_b_info->next_seq;
593 }
594 }
595 }
596 return status;
597}
598
599
600static
601NFCSTATUS
602phHciNfc_Recv_ReaderB_Event(
603 void *psContext,
604 void *pHwRef,
605 uint8_t *pEvent,
606#ifdef ONE_BYTE_LEN
607 uint8_t length
608#else
609 uint16_t length
610#endif
611 )
612{
613 NFCSTATUS status = NFCSTATUS_SUCCESS;
614 phHciNfc_sContext_t *psHciContext =
615 (phHciNfc_sContext_t *)psContext ;
616 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pEvent)
617 || (length == 0))
618 {
619 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
620 }
621 else if((NULL == psHciContext->p_reader_b_info) ||
622 (HCI_READER_B_ENABLE !=
623 ((phHciNfc_ReaderB_Info_t *)(psHciContext->p_reader_b_info))->
624 enable_rdr_b_gate))
625 {
626 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
627 }
628 else
629 {
630 phHciNfc_HCP_Packet_t *p_packet = NULL;
631 phHciNfc_ReaderB_Info_t *p_rdr_b_info=NULL;
632 phHciNfc_HCP_Message_t *message = NULL;
633 uint8_t instruction=0,
634 i = 0;
635
636 p_rdr_b_info = (phHciNfc_ReaderB_Info_t *)
637 psHciContext->p_reader_b_info ;
638 p_packet = (phHciNfc_HCP_Packet_t *)pEvent;
639 message = &p_packet->msg.message;
640 /* Get the instruction bits from the Message Header */
641 instruction = (uint8_t) GET_BITS8( message->msg_header,
642 HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
643
644 if ((EVT_TARGET_DISCOVERED == instruction)
645 && ((RDR_B_MULTIPLE_TAGS_FOUND == message->payload[i] )
646 || (RDR_B_SINGLE_TAG_FOUND == message->payload[i]))
647 )
648 {
649 phNfc_sCompletionInfo_t pCompInfo;
650
651 if (RDR_B_MULTIPLE_TAGS_FOUND == message->payload[i])
652 {
653 p_rdr_b_info->multiple_tgts_found = RDR_B_MULTIPLE_TAGS_FOUND;
654 pCompInfo.status = NFCSTATUS_MULTIPLE_TAGS;
655 }
656 else
657 {
658 p_rdr_b_info->multiple_tgts_found = FALSE;
659 pCompInfo.status = NFCSTATUS_SUCCESS;
660 }
661
662 psHciContext->host_rf_type = phHal_eISO14443_B_PCD;
663 p_rdr_b_info->reader_b_info.RemDevType = phHal_eISO14443_B_PICC;
664 p_rdr_b_info->current_seq = RDR_B_PUPI;
665
666 /* Notify to the HCI Generic layer To Update the FSM */
667 phHciNfc_Notify_Event(psHciContext, pHwRef,
668 NFC_NOTIFY_TARGET_DISCOVERED,
669 &pCompInfo);
670
671 }
672 else
673 {
674 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
675 }
676 }
677 return status;
678}
679
680static
681NFCSTATUS
682phHciNfc_ReaderB_InfoUpdate(
683 phHciNfc_sContext_t *psHciContext,
684 uint8_t index,
685 uint8_t *reg_value,
686 uint8_t reg_length
687 )
688{
689 NFCSTATUS status = NFCSTATUS_SUCCESS;
690 phHciNfc_ReaderB_Info_t *p_rdr_b_info=NULL;
691 phHal_sIso14443BInfo_t *p_tag_b_info = NULL;
692
693 p_rdr_b_info = (phHciNfc_ReaderB_Info_t *)
694 (psHciContext->p_reader_b_info );
695 p_tag_b_info = &(p_rdr_b_info->reader_b_info.RemoteDevInfo.Iso14443B_Info);
696
697 switch(index)
698 {
699 case RDR_B_PUPI_INDEX:
700 {
701 HCI_PRINT_BUFFER("\tReader B PUPI", reg_value, reg_length);
702 /* Update PUPI buffer and length in the remote device info,
703 PUPI length is 4 bytes */
704 if(PHHAL_PUPI_LENGTH == reg_length)
705 {
706 (void)memcpy((void *)p_tag_b_info->AtqB.AtqResInfo.Pupi,
707 (void *)reg_value, reg_length);
708 }
709 else
710 {
711 status = PHNFCSTVAL(CID_NFC_HCI,
712 NFCSTATUS_INVALID_HCI_RESPONSE);
713 }
714 break;
715 }
716 case RDR_B_APP_DATA_INDEX:
717 {
718 HCI_PRINT_BUFFER("\tReader B Application data", reg_value, reg_length);
719 /* Update application data buffer and length, 3 bytes,
720 this includes CRC_B and number of application
721 */
722 if(PHHAL_APP_DATA_B_LENGTH == reg_length)
723 {
724 (void)memcpy((void *)p_tag_b_info->AtqB.AtqResInfo.AppData,
725 (void *)reg_value, reg_length);
726 }
727 else
728 {
729 status = PHNFCSTVAL(CID_NFC_HCI,
730 NFCSTATUS_INVALID_HCI_RESPONSE);
731 }
732 break;
733 }
734 case RDR_B_AFI_INDEX:
735 {
736 HCI_PRINT_BUFFER("\tReader B AFI", reg_value, reg_length);
737 /* Update AFI byte, Only one byte */
738 if(sizeof(*reg_value) == reg_length)
739 {
740 p_tag_b_info->Afi = *reg_value;
741 }
742 else
743 {
744 status = PHNFCSTVAL(CID_NFC_HCI,
745 NFCSTATUS_INVALID_HCI_RESPONSE);
746 }
747 break;
748 }
749
750 case RDR_B_HIGHER_LAYER_RESP_INDEX:
751 {
752 HCI_PRINT_BUFFER("\tReader B higher layer response", reg_value, reg_length);
753 /* Update higher layer response buffer and length */
754 if (reg_length <= PHHAL_MAX_ATR_LENGTH)
755 {
756 (void)memcpy((void *)p_tag_b_info->HiLayerResp,
757 (void *)reg_value, reg_length);
758 }
759 else
760 {
761 status = PHNFCSTVAL(CID_NFC_HCI,
762 NFCSTATUS_INVALID_HCI_RESPONSE);
763 }
764 break;
765 }
766
767 case RDR_B_HIGHER_LAYER_DATA_INDEX:
768 {
769 HCI_PRINT_BUFFER("\tReader B higher layer data", reg_value, reg_length);
770 /* Update higher layer data buffer and length */
771 break;
772 }
773 default:
774 {
775 status = PHNFCSTVAL(CID_NFC_HCI,
776 NFCSTATUS_INVALID_HCI_RESPONSE);
777 break;
778 }
779 }
780 return status;
781}
782
783
784static
785NFCSTATUS
786phHciNfc_Recv_Iso_B_Packet(
787 phHciNfc_sContext_t *psHciContext,
788 uint8_t *pResponse,
789#ifdef ONE_BYTE_LEN
790 uint8_t length
791#else
792 uint16_t length
793#endif
794 )
795{
796 NFCSTATUS status = NFCSTATUS_SUCCESS;
797 uint8_t i = 1;
798
799 psHciContext->rx_index = HCP_HEADER_LEN;
800 /* command WR_XCHG_DATA: so give ISO 14443-4B data to the upper layer */
801 HCI_PRINT_BUFFER("ISO 14443-4B Bytes received", pResponse, length);
802 if(FALSE != pResponse[(length - i)])
803 {
804 status = PHNFCSTVAL(CID_NFC_HCI,
805 NFCSTATUS_RF_ERROR);
806 }
807 return status;
808}
809
810
811NFCSTATUS
812phHciNfc_ReaderB_Set_AFI(
813 void *psContext,
814 void *pHwRef,
815 uint8_t afi_value
816 )
817{
818 NFCSTATUS status = NFCSTATUS_SUCCESS;
819 phHciNfc_sContext_t *psHciContext =
820 (phHciNfc_sContext_t *)psContext ;
821 if( (NULL == psHciContext) || (NULL == pHwRef))
822 {
823 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
824 }
825 else if((NULL == psHciContext->p_reader_b_info) ||
826 (HCI_READER_B_ENABLE !=
827 ((phHciNfc_ReaderB_Info_t *)(psHciContext->p_reader_b_info))->
828 enable_rdr_b_gate))
829 {
830 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
831 }
832 else
833 {
834 phHciNfc_ReaderB_Info_t *ps_rdr_b_info=NULL;
835 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
836 uint8_t pipeid = 0;
837
838 ps_rdr_b_info = (phHciNfc_ReaderB_Info_t *)
839 psHciContext->p_reader_b_info ;
840 p_pipe_info = ps_rdr_b_info->p_pipe_info;
841 if(NULL == p_pipe_info )
842 {
843 status = PHNFCSTVAL(CID_NFC_HCI,
844 NFCSTATUS_INVALID_HCI_SEQUENCE);
845 }
846 else
847 {
848 pipeid = ps_rdr_b_info->pipe_id ;
849 p_pipe_info->reg_index = RDR_B_AFI_INDEX;
850
851 p_pipe_info->param_info = &afi_value;
852 p_pipe_info->param_length = sizeof(uint8_t);
853 /* Fill the data buffer and send the command to the
854 device */
855 status =
856 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
857 pipeid, (uint8_t)ANY_SET_PARAMETER);
858 }
859 }
860 return status;
861}
862
863NFCSTATUS
864phHciNfc_ReaderB_Set_LayerData(
865 void *psContext,
866 void *pHwRef,
867 phNfc_sData_t *layer_data_info
868 )
869{
870 NFCSTATUS status = NFCSTATUS_SUCCESS;
871 phHciNfc_sContext_t *psHciContext =
872 (phHciNfc_sContext_t *)psContext ;
873
874 if( (NULL == psHciContext) || (NULL == pHwRef) ||
875 (NULL == layer_data_info) || (NULL == layer_data_info->buffer)
876 || (0 == layer_data_info->length))
877 {
878 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
879 }
880 else if((NULL == psHciContext->p_reader_b_info) ||
881 (HCI_READER_B_ENABLE !=
882 ((phHciNfc_ReaderB_Info_t *)(psHciContext->p_reader_b_info))->
883 enable_rdr_b_gate))
884 {
885 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
886 }
887 else
888 {
889 phHciNfc_ReaderB_Info_t *ps_rdr_b_info=NULL;
890 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
891 uint8_t pipeid = 0;
892
893 ps_rdr_b_info = (phHciNfc_ReaderB_Info_t *)
894 psHciContext->p_reader_b_info ;
895 p_pipe_info = ps_rdr_b_info->p_pipe_info;
896 if(NULL == p_pipe_info )
897 {
898 status = PHNFCSTVAL(CID_NFC_HCI,
899 NFCSTATUS_INVALID_HCI_SEQUENCE);
900 }
901 else
902 {
903 p_pipe_info->reg_index = RDR_B_HIGHER_LAYER_DATA_INDEX;
904 pipeid = ps_rdr_b_info->pipe_id ;
905 p_pipe_info->param_info = (void *)layer_data_info->buffer;
906 p_pipe_info->param_length = (uint8_t)
907 layer_data_info->length;
908 /* Fill the data buffer and send the command to the
909 device */
910 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
911 pipeid, (uint8_t)ANY_SET_PARAMETER);
912 }
913 }
914 return status;
915}
916#endif /* #if defined (TYPE_B) */
917
918