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_NfcIPMgmt.c *
22 * \brief HCI NFCIP-1 management routines. *
23 * *
24 * *
25 * Project: NFC-FRI-1.1 *
26 * *
27 * $Date: Tue Jun 8 09:32:31 2010 $ *
28 * $Author: ing04880 $ *
29 * $Revision: 1.33 $ *
30 * $Aliases: NFC_FRI1.1_WK1023_R35_1 $
31 * *
32 * =========================================================================== *
33 */
34
35 /*
36 ***************************** Header File Inclusion ****************************
37 */
38 #include <phNfcCompId.h>
39 #include <phNfcHalTypes.h>
40 #include <phHciNfc_Pipe.h>
41 #include <phHciNfc_RFReader.h>
42 #include <phHciNfc_Emulation.h>
43 #include <phOsalNfc.h>
44
45 #if defined (ENABLE_P2P)
46 #include <phHciNfc_NfcIPMgmt.h>
47 /*
48 ****************************** Macro Definitions *******************************
49 */
50 /* RF Error */
51 #define NFCIP_RF_NO_ERROR 0x00U
52 #define NFCIP_STATUS_MAX_VALUE 0x01U
53
54 /* Read and write to the below registry for initiator and target */
55 #define NXP_NFCIP_MODE 0x01U
56 #define NXP_NFCIP_ATR_REQ 0x02U
57 #define NXP_NFCIP_ATR_RES 0x03U
58 #define NXP_NFCIP_PSL1 0x04U
59 #define NXP_NFCIP_PSL2 0x05U
60 #define NXP_NFCIP_DID 0x06U
61 #define NXP_NFCIP_NAD 0x07U
62 #define NXP_NFCIP_OPTIONS 0x08U
63 #define NXP_NFCIP_STATUS 0x09U
64 #define NXP_NFCIP_NFCID3I 0x0AU
65 #define NXP_NFCIP_NFCID3T 0x0BU
66 #define NXP_NFCIP_PARAM 0x0CU
67 #define NXP_NFCIP_MERGE 0x0DU
68
69 /* command */
70 #define NXP_NFCIP_ATTREQUEST 0x12U
71 #define NXP_NFCI_CONTINUE_ACTIVATION 0x13U
72
73 /* Event */
74 #define NXP_EVT_NFC_SND_DATA 0x01U
75 #define NXP_EVT_NFC_ACTIVATED 0x02U
76 #define NXP_EVT_NFC_DEACTIVATED 0x03U
77 #define NXP_EVT_NFC_RCV_DATA 0x04U
78 #define NXP_EVT_NFC_CONTINUE_MI 0x05U
79
80 #define NFCIP_DATE_RATE_FACTOR 0x40U
81 #define NFCIP_DATE_RATE_SHIFT 0x06U
82 #define NFCIP_DATA_RATE_CALC(val) \
83 ((((uint8_t)(val) >> NFCIP_DATE_RATE_SHIFT) + \
84 0x01U) * NFCIP_DATE_RATE_FACTOR)
85 #define NFCIP_COMM_INITIATOR_SHIFT 0x03
86 #define NFCIP_COMM_FACTOR 0x03
87 /*
88 *************************** Structure and Enumeration ***************************
89 */
90
91 /*
92 *************************** Static Function Declaration **************************
93 */
94 static
95 NFCSTATUS
96 phHciNfc_NfcIP_InfoUpdate(
97 phHciNfc_sContext_t *psHciContext,
98 uint8_t index,
99 uint8_t *reg_value,
100 uint8_t reg_length
101 );
102
103 static
104 NFCSTATUS
105 phHciNfc_NfcIP_RecvData(
106 phHciNfc_sContext_t *psHciContext,
107 void *pHwRef,
108 uint8_t *pResponse,
109 #ifdef ONE_BYTE_LEN
110 uint8_t length
111 #else
112 uint16_t length
113 #endif
114 );
115
116 static
117 NFCSTATUS
118 phHciNfc_Recv_NfcIP_Response(
119 phHciNfc_sContext_t *psHciContext,
120 phHciNfc_Pipe_Info_t *ppipe_info,
121 uint8_t *pResponse,
122 #ifdef ONE_BYTE_LEN
123 uint8_t length
124 #else
125 uint16_t length
126 #endif
127 );
128
129 static
130 NFCSTATUS
131 phHciNfc_Recv_NfcIP_Event(
132 phHciNfc_sContext_t *psHciContext,
133 void *pHwRef,
134 uint8_t *pEvent,
135 #ifdef ONE_BYTE_LEN
136 uint8_t length
137 #else
138 uint16_t length
139 #endif
140 );
141
142 static
143 NFCSTATUS
144 phHciNfc_Recv_Initiator_Event(
145 void *psContext,
146 void *pHwRef,
147 uint8_t *pEvent,
148 #ifdef ONE_BYTE_LEN
149 uint8_t length
150 #else
151 uint16_t length
152 #endif
153 );
154
155 static
156 NFCSTATUS
157 phHciNfc_Recv_Target_Event(
158 void *psContext,
159 void *pHwRef,
160 uint8_t *pEvent,
161 #ifdef ONE_BYTE_LEN
162 uint8_t length
163 #else
164 uint16_t length
165 #endif
166 );
167
168 static
169 NFCSTATUS
170 phHciNfc_Recv_Initiator_Response(
171 void *psContext,
172 void *pHwRef,
173 uint8_t *pResponse,
174 #ifdef ONE_BYTE_LEN
175 uint8_t length
176 #else
177 uint16_t length
178 #endif
179 );
180
181 static
182 NFCSTATUS
183 phHciNfc_Recv_Target_Response(
184 void *psContext,
185 void *pHwRef,
186 uint8_t *pResponse,
187 #ifdef ONE_BYTE_LEN
188 uint8_t length
189 #else
190 uint16_t length
191 #endif
192 );
193 /*
194 *************************** Function Definitions ***************************
195 */
196
197 NFCSTATUS
phHciNfc_Initiator_Init_Resources(phHciNfc_sContext_t * psHciContext)198 phHciNfc_Initiator_Init_Resources(
199 phHciNfc_sContext_t *psHciContext
200 )
201 {
202 NFCSTATUS status = NFCSTATUS_SUCCESS;
203 phHciNfc_NfcIP_Info_t *p_init_info=NULL;
204 if( NULL == psHciContext )
205 {
206 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
207 }
208 else
209 {
210 if (NULL != psHciContext->p_nfcip_info)
211 {
212 status = NFCSTATUS_SUCCESS;
213 }
214 else if(( NULL == psHciContext->p_nfcip_info ) &&
215 (phHciNfc_Allocate_Resource((void **)(&p_init_info),
216 sizeof(phHciNfc_NfcIP_Info_t))== NFCSTATUS_SUCCESS)
217 )
218 {
219 psHciContext->p_nfcip_info = p_init_info;
220 p_init_info->nfcip_type = NFCIP_INVALID;
221 p_init_info->current_seq = NFCIP_INVALID_SEQUENCE;
222 p_init_info->next_seq = NFCIP_INVALID_SEQUENCE;
223 p_init_info->p_init_pipe_info = NULL;
224 p_init_info->p_tgt_pipe_info = NULL;
225 }
226 else
227 {
228 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
229 }
230
231 }
232 return status;
233 }
234
235 NFCSTATUS
phHciNfc_Initiator_Get_PipeID(phHciNfc_sContext_t * psHciContext,uint8_t * ppipe_id)236 phHciNfc_Initiator_Get_PipeID(
237 phHciNfc_sContext_t *psHciContext,
238 uint8_t *ppipe_id
239 )
240 {
241 NFCSTATUS status = NFCSTATUS_SUCCESS;
242 if( (NULL != psHciContext)
243 && ( NULL != ppipe_id )
244 && ( NULL != psHciContext->p_nfcip_info )
245 )
246 {
247 phHciNfc_NfcIP_Info_t *p_init_info=NULL;
248 p_init_info = (phHciNfc_NfcIP_Info_t *)
249 psHciContext->p_nfcip_info ;
250 *ppipe_id = p_init_info->p_init_pipe_info->pipe.pipe_id ;
251 }
252 else
253 {
254 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
255 }
256 return status;
257 }
258
259 NFCSTATUS
phHciNfc_Initiator_Update_PipeInfo(phHciNfc_sContext_t * psHciContext,uint8_t pipeID,phHciNfc_Pipe_Info_t * pPipeInfo)260 phHciNfc_Initiator_Update_PipeInfo(
261 phHciNfc_sContext_t *psHciContext,
262 uint8_t pipeID,
263 phHciNfc_Pipe_Info_t *pPipeInfo
264 )
265 {
266 NFCSTATUS status = NFCSTATUS_SUCCESS;
267 if( NULL == psHciContext )
268 {
269 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
270 }
271 else if(NULL == psHciContext->p_nfcip_info)
272 {
273 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
274 }
275 else
276 {
277 phHciNfc_NfcIP_Info_t *p_init_info=NULL;
278 p_init_info = (phHciNfc_NfcIP_Info_t *)
279 psHciContext->p_nfcip_info ;
280 /* Update the pipe_id of the NFCIP-1 initiator Gate obtained from
281 the HCI Response */
282 p_init_info->p_init_pipe_info = pPipeInfo;
283 p_init_info->p_init_pipe_info->pipe.pipe_id = pipeID;
284 /* Update the Response Receive routine of the NFCIP-1 initiator Gate */
285 pPipeInfo->recv_resp = &phHciNfc_Recv_Initiator_Response;
286 /* Update the event Receive routine of the NFCIP-1 initiator Gate */
287 pPipeInfo->recv_event = &phHciNfc_Recv_Initiator_Event;
288 }
289 return status;
290 }
291
292 NFCSTATUS
phHciNfc_NfcIP_Presence_Check(phHciNfc_sContext_t * psHciContext,void * pHwRef)293 phHciNfc_NfcIP_Presence_Check(
294 phHciNfc_sContext_t *psHciContext,
295 void *pHwRef
296 )
297 {
298 NFCSTATUS status = NFCSTATUS_SUCCESS;
299
300 if( (NULL == psHciContext) || (NULL == pHwRef) )
301 {
302 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
303 }
304 else if((NULL == psHciContext->p_nfcip_info) ||
305 (NFCIP_INVALID ==
306 ((phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info))->nfcip_type))
307 {
308 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
309 }
310 else
311 {
312 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
313 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
314
315 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
316 psHciContext->p_nfcip_info ;
317 p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)?
318 p_nfcipinfo->p_init_pipe_info :
319 p_nfcipinfo->p_tgt_pipe_info);
320
321 if(NULL == p_pipe_info )
322 {
323 status = PHNFCSTVAL(CID_NFC_HCI,
324 NFCSTATUS_INVALID_HCI_INFORMATION);
325 }
326 else
327 {
328 phHciNfc_HCP_Packet_t *hcp_packet = NULL;
329 uint16_t length = HCP_HEADER_LEN;
330 uint8_t pipeid = 0;
331
332 pipeid = p_pipe_info->pipe.pipe_id;
333 psHciContext->tx_total = 0 ;
334 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
335 /* Construct the HCP Frame */
336 phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT,
337 (uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_COMMAND,
338 (uint8_t)NXP_NFCIP_ATTREQUEST);
339
340 p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_COMMAND;
341 p_pipe_info->prev_msg = (uint8_t)NXP_NFCIP_ATTREQUEST;
342 psHciContext->tx_total = length;
343 psHciContext->response_pending = (uint8_t)TRUE;
344
345 /* Send the Constructed HCP packet to the lower layer */
346 status = phHciNfc_Send_HCP( psHciContext, pHwRef);
347 p_pipe_info->prev_status = status;
348 }
349 }
350 return status;
351 }
352
353 static
354 NFCSTATUS
phHciNfc_Recv_Initiator_Response(void * pContext,void * pHwRef,uint8_t * pResponse,uint8_t length)355 phHciNfc_Recv_Initiator_Response(
356 void *pContext,
357 void *pHwRef,
358 uint8_t *pResponse,
359 #ifdef ONE_BYTE_LEN
360 uint8_t length
361 #else
362 uint16_t length
363 #endif
364 )
365 {
366 NFCSTATUS status = NFCSTATUS_SUCCESS;
367 phHciNfc_sContext_t *psHciContext =
368 (phHciNfc_sContext_t *)pContext ;
369
370 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse)
371 || (0 == length))
372 {
373 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
374 }
375 else if(NULL == psHciContext->p_nfcip_info)
376 {
377 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
378 }
379 else
380 {
381 phHciNfc_NfcIP_Info_t *p_nfcip_info=NULL;
382 phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
383
384 p_nfcip_info = (phHciNfc_NfcIP_Info_t *)
385 psHciContext->p_nfcip_info ;
386 p_pipe_info = p_nfcip_info->p_init_pipe_info;
387 if( NULL == p_pipe_info)
388 {
389 status = PHNFCSTVAL(CID_NFC_HCI,
390 NFCSTATUS_INVALID_HCI_INFORMATION);
391 }
392 else
393 {
394 status = phHciNfc_Recv_NfcIP_Response(psHciContext,
395 p_pipe_info, pResponse,
396 length);
397 if (NFCSTATUS_SUCCESS == status)
398 {
399 status = phHciNfc_ReaderMgmt_Update_Sequence(psHciContext,
400 UPDATE_SEQ);
401 }
402 }
403 }
404 return status;
405 }
406
407 static
408 NFCSTATUS
phHciNfc_Recv_Initiator_Event(void * psContext,void * pHwRef,uint8_t * pEvent,uint8_t length)409 phHciNfc_Recv_Initiator_Event(
410 void *psContext,
411 void *pHwRef,
412 uint8_t *pEvent,
413 #ifdef ONE_BYTE_LEN
414 uint8_t length
415 #else
416 uint16_t length
417 #endif
418 )
419 {
420 NFCSTATUS status = NFCSTATUS_SUCCESS;
421 phHciNfc_sContext_t *psHciContext =
422 (phHciNfc_sContext_t *)psContext ;
423 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pEvent)
424 || (0 == length))
425 {
426 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
427 }
428 else if(NULL == psHciContext->p_nfcip_info)
429 {
430 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
431 }
432 else
433 {
434 phHciNfc_HCP_Packet_t *p_packet = NULL;
435 phHciNfc_NfcIP_Info_t *p_nfcip_info=NULL;
436 phHciNfc_HCP_Message_t *message = NULL;
437 uint8_t instruction=0;
438
439 p_nfcip_info = (phHciNfc_NfcIP_Info_t *)
440 psHciContext->p_nfcip_info ;
441 p_packet = (phHciNfc_HCP_Packet_t *)pEvent;
442 message = &p_packet->msg.message;
443 /* Get the instruction bits from the Message Header */
444 instruction = (uint8_t) GET_BITS8( message->msg_header,
445 HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
446 if (NXP_EVT_NFC_ACTIVATED == instruction)
447 {
448 p_nfcip_info->nfcip_type = NFCIP_INITIATOR;
449 psHciContext->host_rf_type = phHal_eNfcIP1_Initiator;
450 p_nfcip_info->rem_nfcip_tgt_info.RemDevType = phHal_eNfcIP1_Target;
451 }
452
453 status = phHciNfc_Recv_NfcIP_Event(psHciContext,
454 pHwRef, pEvent, length);
455 }
456 return status;
457 }
458
459 NFCSTATUS
phHciNfc_Target_Init_Resources(phHciNfc_sContext_t * psHciContext)460 phHciNfc_Target_Init_Resources(
461 phHciNfc_sContext_t *psHciContext
462 )
463 {
464 NFCSTATUS status = NFCSTATUS_SUCCESS;
465 phHciNfc_NfcIP_Info_t *p_target_info=NULL;
466 if( NULL == psHciContext )
467 {
468 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
469 }
470 else
471 {
472 if (NULL != psHciContext->p_nfcip_info)
473 {
474 status = NFCSTATUS_SUCCESS;
475 }
476 else if(
477 ( NULL == psHciContext->p_nfcip_info ) &&
478 (phHciNfc_Allocate_Resource((void **)(&p_target_info),
479 sizeof(phHciNfc_NfcIP_Info_t))== NFCSTATUS_SUCCESS)
480 )
481 {
482 psHciContext->p_nfcip_info = p_target_info;
483 p_target_info->nfcip_type = NFCIP_INVALID;
484 p_target_info->current_seq = NFCIP_INVALID_SEQUENCE;
485 p_target_info->next_seq = NFCIP_INVALID_SEQUENCE;
486 p_target_info->p_tgt_pipe_info = NULL;
487 p_target_info->p_tgt_pipe_info = NULL;
488 }
489 else
490 {
491 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
492 }
493
494 }
495 return status;
496 }
497
498 NFCSTATUS
phHciNfc_Target_Get_PipeID(phHciNfc_sContext_t * psHciContext,uint8_t * ppipe_id)499 phHciNfc_Target_Get_PipeID(
500 phHciNfc_sContext_t *psHciContext,
501 uint8_t *ppipe_id
502 )
503 {
504 NFCSTATUS status = NFCSTATUS_SUCCESS;
505 if( (NULL != psHciContext)
506 && ( NULL != ppipe_id )
507 && ( NULL != psHciContext->p_nfcip_info )
508 )
509 {
510 phHciNfc_NfcIP_Info_t *p_target_info=NULL;
511 p_target_info = (phHciNfc_NfcIP_Info_t *)
512 psHciContext->p_nfcip_info ;
513 *ppipe_id = p_target_info->p_tgt_pipe_info->pipe.pipe_id;
514 }
515 else
516 {
517 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
518 }
519 return status;
520 }
521
522 NFCSTATUS
phHciNfc_Target_Update_PipeInfo(phHciNfc_sContext_t * psHciContext,uint8_t pipeID,phHciNfc_Pipe_Info_t * pPipeInfo)523 phHciNfc_Target_Update_PipeInfo(
524 phHciNfc_sContext_t *psHciContext,
525 uint8_t pipeID,
526 phHciNfc_Pipe_Info_t *pPipeInfo
527 )
528 {
529 NFCSTATUS status = NFCSTATUS_SUCCESS;
530 if( NULL == psHciContext )
531 {
532 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
533 }
534 else if(NULL == psHciContext->p_nfcip_info)
535 {
536 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
537 }
538 else
539 {
540 phHciNfc_NfcIP_Info_t *p_target_info=NULL;
541 p_target_info = (phHciNfc_NfcIP_Info_t *)
542 psHciContext->p_nfcip_info ;
543 /* Update the pipe_id of the NFCIP-1 target Gate obtained from
544 the HCI Response */
545 p_target_info->p_tgt_pipe_info = pPipeInfo;
546 p_target_info->p_tgt_pipe_info->pipe.pipe_id = pipeID;
547 /* Update the Response Receive routine of the NFCIP-1 target Gate */
548 pPipeInfo->recv_resp = &phHciNfc_Recv_Target_Response;
549 /* Update the event Receive routine of the NFCIP-1 target Gate */
550 pPipeInfo->recv_event = &phHciNfc_Recv_Target_Event;
551 }
552 return status;
553 }
554
555 static
556 NFCSTATUS
phHciNfc_Recv_Target_Response(void * pContext,void * pHwRef,uint8_t * pResponse,uint8_t length)557 phHciNfc_Recv_Target_Response(
558 void *pContext,
559 void *pHwRef,
560 uint8_t *pResponse,
561 #ifdef ONE_BYTE_LEN
562 uint8_t length
563 #else
564 uint16_t length
565 #endif
566 )
567 {
568 NFCSTATUS status = NFCSTATUS_SUCCESS;
569 phHciNfc_sContext_t *psHciContext =
570 (phHciNfc_sContext_t *)pContext ;
571
572 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse)
573 || (0 == length))
574 {
575 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
576 }
577 else if(NULL == psHciContext->p_nfcip_info)
578 {
579 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
580 }
581 else
582 {
583 phHciNfc_NfcIP_Info_t *p_nfcip_info=NULL;
584 phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
585
586 p_nfcip_info = (phHciNfc_NfcIP_Info_t *)
587 psHciContext->p_nfcip_info ;
588 p_pipe_info = p_nfcip_info->p_tgt_pipe_info;
589 if( NULL == p_pipe_info)
590 {
591 status = PHNFCSTVAL(CID_NFC_HCI,
592 NFCSTATUS_INVALID_HCI_INFORMATION);
593 }
594 else
595 {
596 status = phHciNfc_Recv_NfcIP_Response(psHciContext,
597 p_pipe_info, pResponse,
598 length);
599 if (NFCSTATUS_SUCCESS == status)
600 {
601 status = phHciNfc_EmuMgmt_Update_Seq(psHciContext,
602 UPDATE_SEQ);
603 }
604 }
605 }
606 return status;
607 }
608
609 static
610 NFCSTATUS
phHciNfc_Recv_Target_Event(void * psContext,void * pHwRef,uint8_t * pEvent,uint8_t length)611 phHciNfc_Recv_Target_Event(
612 void *psContext,
613 void *pHwRef,
614 uint8_t *pEvent,
615 #ifdef ONE_BYTE_LEN
616 uint8_t length
617 #else
618 uint16_t length
619 #endif
620 )
621 {
622 NFCSTATUS status = NFCSTATUS_SUCCESS;
623 phHciNfc_sContext_t *psHciContext =
624 (phHciNfc_sContext_t *)psContext ;
625 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pEvent)
626 || (0 == length))
627 {
628 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
629 }
630 else if(NULL == psHciContext->p_nfcip_info)
631 {
632 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
633 }
634 else
635 {
636 phHciNfc_HCP_Packet_t *p_packet = NULL;
637 phHciNfc_NfcIP_Info_t *p_nfcip_info=NULL;
638 phHciNfc_HCP_Message_t *message = NULL;
639 uint8_t instruction=0;
640
641 p_nfcip_info = (phHciNfc_NfcIP_Info_t *)psHciContext->p_nfcip_info ;
642 p_packet = (phHciNfc_HCP_Packet_t *)pEvent;
643 message = &p_packet->msg.message;
644 /* Get the instruction bits from the Message Header */
645 instruction = (uint8_t) GET_BITS8( message->msg_header,
646 HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
647 if (NXP_EVT_NFC_ACTIVATED == instruction)
648 {
649 p_nfcip_info->nfcip_type = NFCIP_TARGET;
650 psHciContext->host_rf_type = phHal_eNfcIP1_Target;
651 p_nfcip_info->rem_nfcip_tgt_info.RemDevType =
652 phHal_eNfcIP1_Initiator;
653 }
654 status = phHciNfc_Recv_NfcIP_Event(psHciContext,
655 pHwRef, pEvent, length);
656 }
657 return status;
658 }
659
660 static
661 NFCSTATUS
phHciNfc_Recv_NfcIP_Response(phHciNfc_sContext_t * psHciContext,phHciNfc_Pipe_Info_t * ppipe_info,uint8_t * pResponse,uint8_t length)662 phHciNfc_Recv_NfcIP_Response(
663 phHciNfc_sContext_t *psHciContext,
664 phHciNfc_Pipe_Info_t *ppipe_info,
665 uint8_t *pResponse,
666 #ifdef ONE_BYTE_LEN
667 uint8_t length
668 #else
669 uint16_t length
670 #endif
671 )
672 {
673 NFCSTATUS status = NFCSTATUS_SUCCESS;
674 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
675 uint8_t prev_cmd = ANY_GET_PARAMETER;
676
677 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
678 psHciContext->p_nfcip_info ;
679 prev_cmd = ppipe_info->prev_msg ;
680 switch(prev_cmd)
681 {
682 case ANY_OPEN_PIPE:
683 {
684 HCI_PRINT("NFCIP-1 NFCIP open pipe complete\n");
685 p_nfcipinfo->next_seq = NFCIP_NFCID3I;
686 break;
687 }
688 case ANY_CLOSE_PIPE:
689 {
690 HCI_PRINT("NFCIP-1 NFCIP close pipe complete\n");
691 p_nfcipinfo->next_seq = NFCIP_NFCID3I;
692 break;
693 }
694 case ANY_GET_PARAMETER:
695 {
696 HCI_PRINT("NFCIP-1 NFCIP get parameter complete\n");
697 if (length >= HCP_HEADER_LEN)
698 {
699 status = phHciNfc_NfcIP_InfoUpdate(psHciContext,
700 ppipe_info->reg_index,
701 &pResponse[HCP_HEADER_LEN],
702 (uint8_t)(length - HCP_HEADER_LEN));
703 }
704 else
705 {
706 status = PHNFCSTVAL(CID_NFC_HCI,
707 NFCSTATUS_INVALID_HCI_RESPONSE);
708 }
709 break;
710 }
711 case ANY_SET_PARAMETER:
712 {
713 HCI_PRINT("NFCIP-1 NFCIP Parameter Set \n");
714 p_nfcipinfo->next_seq = NFCIP_NFCID3I;
715 break;
716 }
717 case NXP_NFCI_CONTINUE_ACTIVATION:
718 case NXP_NFCIP_ATTREQUEST:
719 {
720 p_nfcipinfo->next_seq = NFCIP_NFCID3I;
721 break;
722 }
723 default:
724 {
725 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
726 break;
727 }
728 }
729
730 if( NFCSTATUS_SUCCESS == status )
731 {
732 ppipe_info->prev_status = NFCSTATUS_SUCCESS;
733 p_nfcipinfo->current_seq = p_nfcipinfo->next_seq;
734 }
735 return status;
736 }
737
738 static
739 NFCSTATUS
phHciNfc_Recv_NfcIP_Event(phHciNfc_sContext_t * psHciContext,void * pHwRef,uint8_t * pEvent,uint8_t length)740 phHciNfc_Recv_NfcIP_Event(
741 phHciNfc_sContext_t *psHciContext,
742 void *pHwRef,
743 uint8_t *pEvent,
744 #ifdef ONE_BYTE_LEN
745 uint8_t length
746 #else
747 uint16_t length
748 #endif
749 )
750 {
751 NFCSTATUS status = NFCSTATUS_SUCCESS;
752 phHciNfc_HCP_Packet_t *p_packet = NULL;
753 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
754 phHciNfc_HCP_Message_t *message = NULL;
755 phNfc_sCompletionInfo_t pCompInfo;
756 uint8_t instruction=0;
757 uint8_t type = 0;
758
759 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
760 psHciContext->p_nfcip_info ;
761 p_packet = (phHciNfc_HCP_Packet_t *)pEvent;
762 message = &p_packet->msg.message;
763 /* Get the instruction bits from the Message Header */
764 instruction = (uint8_t) GET_BITS8( message->msg_header,
765 HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
766
767 switch(instruction)
768 {
769 case NXP_EVT_NFC_ACTIVATED:
770 {
771 HCI_PRINT("NFCIP-1 device discovered\n");
772
773 if (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)
774 {
775 pCompInfo.info = &(p_nfcipinfo->rem_nfcip_tgt_info);
776 type = NFC_NOTIFY_TARGET_DISCOVERED;
777 }
778 else
779 {
780 type = NFC_NOTIFY_DEVICE_ACTIVATED;
781 }
782
783 if(length > HCP_HEADER_LEN)
784 {
785 HCI_DEBUG("NfcIP-1 activation mode : %d\n", pEvent[HCP_HEADER_LEN]);
786 /* Mode indicates in which mode the current activation
787 as be done
788 - 0x00: Passive mode
789 - 0x01: Active */
790 p_nfcipinfo->activation_mode = pEvent[HCP_HEADER_LEN];
791 }
792 pCompInfo.status = NFCSTATUS_SUCCESS;
793 /* Notify to the HCI Generic layer To Update the FSM */
794 phHciNfc_Notify_Event(psHciContext, pHwRef,
795 type, &pCompInfo);
796 break;
797 }
798 case NXP_EVT_NFC_DEACTIVATED:
799 {
800 static phHal_sEventInfo_t event_info;
801
802 event_info.eventHost = phHal_eHostController;
803 event_info.eventType = NFC_EVT_DEACTIVATED;
804 p_nfcipinfo->activation_mode = FALSE;
805 if (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)
806 {
807 p_nfcipinfo->rem_nfcip_tgt_info.RemDevType =
808 phHal_eNfcIP1_Target;
809 event_info.eventSource = phHal_eNfcIP1_Initiator;
810 }
811 else
812 {
813 p_nfcipinfo->rem_nfcip_tgt_info.RemDevType =
814 phHal_eNfcIP1_Initiator;
815 event_info.eventSource = phHal_eNfcIP1_Target;
816 }
817 /* Reset the sequence */
818 p_nfcipinfo->current_seq = NFCIP_NFCID3I;
819 p_nfcipinfo->next_seq = NFCIP_NFCID3I;
820
821 HCI_PRINT("NFCIP-1 Target Deactivated\n");
822 phHciNfc_Notify_Event(psHciContext, pHwRef,
823 NFC_NOTIFY_DEVICE_DEACTIVATED,
824 &event_info);
825 break;
826 }
827 case NXP_EVT_NFC_RCV_DATA:
828 {
829 status = phHciNfc_NfcIP_RecvData(psHciContext,
830 pHwRef,
831 &pEvent[HCP_HEADER_LEN],
832 (length - HCP_HEADER_LEN));
833 break;
834 }
835 case NXP_EVT_NFC_CONTINUE_MI:
836 {
837 /* psHciContext->response_pending = FALSE; */
838 psHciContext->event_pending = FALSE;
839 break;
840 }
841 default:
842 {
843 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
844 break;
845 }
846 }
847
848 return status;
849 }
850
851 static
852 NFCSTATUS
phHciNfc_NfcIP_RecvData(phHciNfc_sContext_t * psHciContext,void * pHwRef,uint8_t * pResponse,uint8_t length)853 phHciNfc_NfcIP_RecvData(
854 phHciNfc_sContext_t *psHciContext,
855 void *pHwRef,
856 uint8_t *pResponse,
857 #ifdef ONE_BYTE_LEN
858 uint8_t length
859 #else
860 uint16_t length
861 #endif
862 )
863 {
864 NFCSTATUS status = NFCSTATUS_SUCCESS;
865 uint8_t index = 0;
866
867 if( (NULL == psHciContext)
868 || (NULL == pHwRef)
869 || (NULL == pResponse)
870 || (0 == length))
871 {
872 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
873 }
874 else
875 {
876 phNfc_sTransactionInfo_t transInfo;
877 phHciNfc_NfcIP_Info_t *p_nfcipinfo = NULL;
878 uint8_t type = 0;
879
880 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
881 psHciContext->p_nfcip_info;
882 HCI_PRINT("NFCIP-1 received bytes :");
883 if (NFCIP_RF_NO_ERROR == pResponse[index])
884 {
885 HCI_PRINT_BUFFER("device ", &pResponse[index], (length - index));
886 transInfo.status = NFCSTATUS_SUCCESS;
887 index++;
888 if (TRUE == pResponse[index])
889 {
890 /* Update the more information bit to the upper layer */
891 transInfo.status = NFCSTATUS_MORE_INFORMATION;
892 }
893 index++;
894
895
896 transInfo.buffer = &pResponse[index];
897 transInfo.length = (length - index);
898 type = (uint8_t)NFC_NOTIFY_RECV_EVENT;
899 }
900 else
901 {
902 HCI_PRINT("NFCIP-1 receive RF ERROR ");
903 p_nfcipinfo->activation_mode = FALSE;
904 type = (uint8_t)NFC_NOTIFY_RECV_EVENT;
905 transInfo.status = NFCSTATUS_RF_TIMEOUT;
906 transInfo.buffer = NULL;
907 transInfo.length = 0;
908 }
909 status = NFCSTATUS_PENDING;
910 /* Event NXP_EVT_NFC_RCV_DATA: so give received data to
911 the upper layer */
912 phHciNfc_Notify_Event(psHciContext, pHwRef,
913 type,
914 &transInfo );
915 }
916 return status;
917 }
918
919 NFCSTATUS
phHciNfc_NfcIP_Send_Data(phHciNfc_sContext_t * psHciContext,void * pHwRef,phHciNfc_XchgInfo_t * sData)920 phHciNfc_NfcIP_Send_Data (
921 phHciNfc_sContext_t *psHciContext,
922 void *pHwRef,
923 phHciNfc_XchgInfo_t *sData
924 )
925 {
926 NFCSTATUS status = NFCSTATUS_SUCCESS;
927
928 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == sData) ||
929 (NULL == sData->tx_buffer) || (0 == sData->tx_length))
930 {
931 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
932 }
933 else if((NULL == psHciContext->p_nfcip_info) ||
934 (NFCIP_INVALID ==
935 ((phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info))->nfcip_type))
936 {
937 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
938 }
939 else
940 {
941 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
942 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
943
944 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
945 psHciContext->p_nfcip_info ;
946 p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)?
947 p_nfcipinfo->p_init_pipe_info :
948 p_nfcipinfo->p_tgt_pipe_info);
949
950 if(NULL == p_pipe_info )
951 {
952 status = PHNFCSTVAL(CID_NFC_HCI,
953 NFCSTATUS_INVALID_HCI_INFORMATION);
954 }
955 else
956 {
957 phHciNfc_HCP_Packet_t *hcp_packet = NULL;
958 phHciNfc_HCP_Message_t *hcp_message = NULL;
959 uint16_t length = HCP_HEADER_LEN;
960 uint8_t pipeid = 0,
961 i = 0;
962
963 HCI_PRINT_BUFFER("HCI NFCIP-1 Send Data: ", sData->tx_buffer, sData->tx_length);
964
965 psHciContext->tx_total = 0 ;
966 pipeid = p_pipe_info->pipe.pipe_id;
967 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
968 hcp_message = &(hcp_packet->msg.message);
969 hcp_message->payload[i] = sData->params.nfc_info.more_info;
970 i++;
971
972 /* Construct the HCP Frame */
973 phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT,
974 (uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_EVENT,
975 (uint8_t)NXP_EVT_NFC_SND_DATA);
976
977 phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload,
978 i, (uint8_t *)sData->tx_buffer,
979 (uint8_t)sData->tx_length);
980
981 length =(uint16_t)(length + i + sData->tx_length);
982
983 p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_EVENT;
984 p_pipe_info->prev_msg = NXP_EVT_NFC_SND_DATA;
985 psHciContext->tx_total = length;
986 /* Send the Constructed HCP packet to the lower layer */
987 status = phHciNfc_Send_HCP( psHciContext, pHwRef);
988 #if !defined (ENABLE_CONTINUE_MI)
989 if ((TRUE == sData->params.nfc_info.more_info) &&
990 (NFCSTATUS_PENDING == status))
991 {
992 /* If more information bit is set, then wait for the event
993 NXP_EVT_NFC_CONTINUE_MI */
994 /* psHciContext->response_pending = TRUE; */
995 psHciContext->event_pending = TRUE;
996 }
997 #endif /* #if defined (ENABLE_CONTINUE_MI) */
998 p_pipe_info->prev_status = status;
999 }
1000 }
1001 return status;
1002 }
1003
1004 NFCSTATUS
phHciNfc_NfcIP_Info_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef,uint8_t notify_reqd)1005 phHciNfc_NfcIP_Info_Sequence (
1006 phHciNfc_sContext_t *psHciContext,
1007 void *pHwRef
1008 #ifdef NOTIFY_REQD
1009 ,
1010 uint8_t notify_reqd
1011 #endif /* #ifdef NOTIFY_REQD */
1012 )
1013 {
1014 NFCSTATUS status = NFCSTATUS_SUCCESS;
1015
1016 if( (NULL == psHciContext)
1017 || (NULL == pHwRef)
1018 )
1019 {
1020 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1021 }
1022 else if((NULL == psHciContext->p_nfcip_info) ||
1023 (NFCIP_INVALID ==
1024 ((phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info))->
1025 nfcip_type))
1026 {
1027 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1028 }
1029 else
1030 {
1031 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
1032 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
1033
1034 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
1035 psHciContext->p_nfcip_info ;
1036 p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)?
1037 p_nfcipinfo->p_init_pipe_info:
1038 p_nfcipinfo->p_tgt_pipe_info);
1039 if(NULL == p_pipe_info )
1040 {
1041 status = PHNFCSTVAL(CID_NFC_HCI,
1042 NFCSTATUS_INVALID_HCI_INFORMATION);
1043 }
1044 else
1045 {
1046 switch(p_nfcipinfo->current_seq)
1047 {
1048 case NFCIP_NFCID3I:
1049 {
1050 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_NFCID3I;
1051 /* Fill the data buffer and send the command to the
1052 device */
1053 status =
1054 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1055 p_pipe_info->pipe.pipe_id,
1056 ANY_GET_PARAMETER);
1057 if(NFCSTATUS_PENDING == status )
1058 {
1059 p_nfcipinfo->next_seq = NFCIP_NFCID3T;
1060 }
1061 break;
1062 }
1063 case NFCIP_NFCID3T:
1064 {
1065 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_NFCID3T;
1066 /* Fill the data buffer and send the command to the
1067 device */
1068 status =
1069 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1070 p_pipe_info->pipe.pipe_id,
1071 ANY_GET_PARAMETER);
1072 if(NFCSTATUS_PENDING == status )
1073 {
1074 p_nfcipinfo->next_seq = NFCIP_PARAM;
1075 }
1076 break;
1077 }
1078 case NFCIP_PARAM:
1079 {
1080 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PARAM;
1081 /* Fill the data buffer and send the command to the
1082 device */
1083 status =
1084 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1085 p_pipe_info->pipe.pipe_id,
1086 ANY_GET_PARAMETER);
1087 if(NFCSTATUS_PENDING == status )
1088 {
1089 p_nfcipinfo->next_seq = NFCIP_ATR_INFO;
1090 }
1091 break;
1092 }
1093 case NFCIP_ATR_INFO:
1094 {
1095 p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR ==
1096 p_nfcipinfo->nfcip_type)?
1097 NXP_NFCIP_ATR_RES :
1098 NXP_NFCIP_ATR_REQ);
1099 status =
1100 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1101 p_pipe_info->pipe.pipe_id,
1102 ANY_GET_PARAMETER);
1103
1104 if(NFCSTATUS_PENDING == status )
1105 {
1106 p_nfcipinfo->next_seq = NFCIP_STATUS;
1107 }
1108 break;
1109 }
1110 case NFCIP_STATUS:
1111 {
1112 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_STATUS;
1113 /* Fill the data buffer and send the command to the
1114 device */
1115 status =
1116 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1117 p_pipe_info->pipe.pipe_id,
1118 ANY_GET_PARAMETER);
1119 if(NFCSTATUS_PENDING == status )
1120 {
1121 #ifdef NOTIFY_REQD
1122 if(FALSE == notify_reqd)
1123 #else /* #ifdef NOTIFY_REQD */
1124 if (NULL != psHciContext->p_target_info)
1125 #endif /* #ifdef NOTIFY_REQD */
1126 {
1127 p_nfcipinfo->next_seq = NFCIP_NFCID3I;
1128 status = NFCSTATUS_SUCCESS;
1129 }
1130 else
1131 {
1132 p_nfcipinfo->next_seq = NFCIP_END_SEQUENCE;
1133 }
1134 }
1135 break;
1136 }
1137 case NFCIP_END_SEQUENCE:
1138 {
1139 phHal_uRemoteDevInfo_t *rem_nfcipinfo = NULL;
1140
1141 if (NULL != psHciContext->p_target_info)
1142 {
1143 /* This is given to user */
1144 rem_nfcipinfo =
1145 &(psHciContext->p_target_info->RemoteDevInfo);
1146 }
1147 else
1148 {
1149 rem_nfcipinfo =
1150 &(p_nfcipinfo->rem_nfcip_tgt_info.RemoteDevInfo);
1151 }
1152
1153 /* Update maximum frame length */
1154 rem_nfcipinfo->NfcIP_Info.MaxFrameLength =
1155 p_nfcipinfo->max_frame_len;
1156
1157 p_nfcipinfo->current_seq = NFCIP_NFCID3I;
1158 p_nfcipinfo->next_seq = NFCIP_NFCID3I;
1159
1160 rem_nfcipinfo->NfcIP_Info.Nfcip_Active =
1161 p_nfcipinfo->activation_mode;
1162
1163
1164 if (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)
1165 {
1166 phNfc_sCompletionInfo_t CompInfo;
1167
1168 p_nfcipinfo->rem_nfcip_tgt_info.RemDevType =
1169 phHal_eNfcIP1_Target;
1170
1171 /* Update initiator speed */
1172 rem_nfcipinfo->NfcIP_Info.Nfcip_Datarate =
1173 (phHalNfc_eDataRate_t)
1174 (p_nfcipinfo->initiator_speed);
1175
1176
1177 /* Update ATR info */
1178 rem_nfcipinfo->NfcIP_Info.ATRInfo_Length =
1179 p_nfcipinfo->atr_res_length;
1180 (void)memcpy(
1181 (void *)rem_nfcipinfo->NfcIP_Info.ATRInfo,
1182 (void *)p_nfcipinfo->atr_res_info,
1183 rem_nfcipinfo->NfcIP_Info.ATRInfo_Length);
1184
1185 /* Update NFCID */
1186 rem_nfcipinfo->NfcIP_Info.NFCID_Length =
1187 p_nfcipinfo->nfcid3i_length;
1188 (void)memcpy(
1189 (void *)rem_nfcipinfo->NfcIP_Info.NFCID,
1190 (void *)p_nfcipinfo->nfcid3i,
1191 rem_nfcipinfo->NfcIP_Info.NFCID_Length);
1192
1193 CompInfo.status = status = NFCSTATUS_SUCCESS;
1194 if (NULL != psHciContext->p_target_info)
1195 {
1196 CompInfo.info = &(psHciContext->p_target_info);
1197 }
1198 else
1199 {
1200 CompInfo.info = &(p_nfcipinfo->rem_nfcip_tgt_info);
1201 }
1202 /* Notify to the upper layer */
1203 phHciNfc_Tag_Notify(psHciContext, pHwRef,
1204 NFC_NOTIFY_TARGET_DISCOVERED,
1205 &CompInfo);
1206 }
1207 else
1208 {
1209 static phHal_sEventInfo_t event_info;
1210
1211 p_nfcipinfo->rem_nfcip_tgt_info.RemDevType =
1212 phHal_eNfcIP1_Initiator;
1213
1214 /* Update target speed */
1215 rem_nfcipinfo->NfcIP_Info.Nfcip_Datarate =
1216 (phHalNfc_eDataRate_t)
1217 (p_nfcipinfo->target_speed);
1218 /* Update ATR info */
1219 rem_nfcipinfo->NfcIP_Info.ATRInfo_Length =
1220 p_nfcipinfo->atr_req_length;
1221 (void)memcpy(
1222 (void *)rem_nfcipinfo->NfcIP_Info.ATRInfo,
1223 (void *)p_nfcipinfo->atr_req_info,
1224 rem_nfcipinfo->NfcIP_Info.ATRInfo_Length);
1225
1226 /* Update NFCID */
1227 rem_nfcipinfo->NfcIP_Info.NFCID_Length =
1228 p_nfcipinfo->nfcid3t_length;
1229 (void)memcpy(
1230 (void *)rem_nfcipinfo->NfcIP_Info.NFCID,
1231 (void *)p_nfcipinfo->nfcid3t,
1232 rem_nfcipinfo->NfcIP_Info.NFCID_Length);
1233
1234 event_info.eventHost = phHal_eHostController;
1235 event_info.eventType = NFC_EVT_ACTIVATED;
1236 event_info.eventSource = phHal_eNfcIP1_Target;
1237 event_info.eventInfo.pRemoteDevInfo =
1238 &(p_nfcipinfo->rem_nfcip_tgt_info);
1239
1240 phHciNfc_Target_Select_Notify((void *)psHciContext,
1241 pHwRef,
1242 NFC_NOTIFY_EVENT,
1243 &(event_info));
1244 }
1245 break;
1246 }
1247 default:
1248 {
1249 status = PHNFCSTVAL(CID_NFC_HCI,
1250 NFCSTATUS_INVALID_HCI_RESPONSE);
1251 break;
1252 }
1253 }
1254 }
1255 }
1256 return status;
1257 }
1258
1259 static
1260 NFCSTATUS
phHciNfc_NfcIP_InfoUpdate(phHciNfc_sContext_t * psHciContext,uint8_t index,uint8_t * reg_value,uint8_t reg_length)1261 phHciNfc_NfcIP_InfoUpdate(
1262 phHciNfc_sContext_t *psHciContext,
1263 uint8_t index,
1264 uint8_t *reg_value,
1265 uint8_t reg_length
1266 )
1267 {
1268 NFCSTATUS status = NFCSTATUS_SUCCESS;
1269 phHciNfc_NfcIP_Info_t *p_nfcipinfo = NULL;
1270 phHal_sNfcIPInfo_t *p_rem_nfcipinfo = NULL;
1271
1272 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)(psHciContext->p_nfcip_info );
1273 p_rem_nfcipinfo = &(p_nfcipinfo->rem_nfcip_tgt_info.RemoteDevInfo.NfcIP_Info);
1274
1275
1276 switch(index)
1277 {
1278 case NXP_NFCIP_ATR_RES:
1279 {
1280 if (reg_length <= NFCIP_ATR_MAX_LENGTH)
1281 {
1282 /* Remote device info provided by the user */
1283
1284 HCI_PRINT_BUFFER("\tNFCIP ATR_RES", reg_value, reg_length);
1285
1286 p_rem_nfcipinfo->ATRInfo_Length =
1287 p_nfcipinfo->atr_res_length = reg_length;
1288
1289 (void)memcpy((void *)p_rem_nfcipinfo->ATRInfo,
1290 (void *)reg_value,
1291 p_rem_nfcipinfo->ATRInfo_Length);
1292
1293 (void)memcpy((void *)p_nfcipinfo->atr_res_info,
1294 (void *)reg_value,
1295 p_nfcipinfo->atr_res_length);
1296 if (NULL != psHciContext->p_target_info)
1297 {
1298 phHal_sNfcIPInfo_t *p_remtgt_info = NULL;
1299 /* This is given to user */
1300 p_remtgt_info =
1301 &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
1302 p_remtgt_info->ATRInfo_Length = reg_length;
1303 (void)memcpy((void *)p_remtgt_info->ATRInfo,
1304 (void *)reg_value,
1305 p_remtgt_info->ATRInfo_Length);
1306 }
1307 }
1308 else
1309 {
1310 status = PHNFCSTVAL(CID_NFC_HCI,
1311 NFCSTATUS_INVALID_HCI_RESPONSE);
1312 }
1313 break;
1314 }
1315 case NXP_NFCIP_STATUS:
1316 {
1317 if (sizeof(*reg_value) == reg_length)
1318 #ifdef STATUS_BUFFER_CHECK
1319 && (*reg_value <= NFCIP_STATUS_MAX_VALUE))
1320 #endif /* #ifdef STATUS_ERROR */
1321 {
1322 HCI_PRINT_BUFFER("\tNFCIP STATUS", reg_value, reg_length);
1323 p_nfcipinfo->linkstatus = *reg_value;
1324 }
1325 else
1326 {
1327 status = PHNFCSTVAL(CID_NFC_HCI,
1328 NFCSTATUS_INVALID_HCI_RESPONSE);
1329 }
1330 break;
1331 }
1332 case NXP_NFCIP_NFCID3I:
1333 {
1334 if (reg_length <= NFCIP_NFCID_LENGTH)
1335 {
1336 HCI_PRINT_BUFFER("\tNFCIP NFCID3I", reg_value, reg_length);
1337 p_nfcipinfo->nfcid3i_length =
1338 p_rem_nfcipinfo->NFCID_Length = reg_length;
1339 (void)memcpy((void *)p_rem_nfcipinfo->NFCID,
1340 (void *)reg_value,
1341 p_rem_nfcipinfo->NFCID_Length);
1342 (void)memcpy((void *)p_nfcipinfo->nfcid3i,
1343 (void *)reg_value,
1344 reg_length);
1345 if ((NULL != psHciContext->p_target_info) &&
1346 (NFCIP_INITIATOR == p_nfcipinfo->nfcip_type))
1347 {
1348 phHal_sNfcIPInfo_t *p_remtgt_info = NULL;
1349 /* This is given to user */
1350 p_remtgt_info =
1351 &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
1352 p_remtgt_info->NFCID_Length = reg_length;
1353 (void)memcpy((void *)p_remtgt_info->NFCID,
1354 (void *)reg_value,
1355 p_remtgt_info->NFCID_Length);
1356 }
1357 }
1358 else
1359 {
1360 status = PHNFCSTVAL(CID_NFC_HCI,
1361 NFCSTATUS_INVALID_HCI_RESPONSE);
1362 }
1363 break;
1364 }
1365 case NXP_NFCIP_NFCID3T:
1366 {
1367 if (reg_length <= NFCIP_NFCID_LENGTH)
1368 {
1369 HCI_PRINT_BUFFER("\tNFCIP NFCID3T", reg_value, reg_length);
1370 p_nfcipinfo->nfcid3t_length =
1371 p_rem_nfcipinfo->NFCID_Length = reg_length;
1372 (void)memcpy((void *)p_rem_nfcipinfo->NFCID,
1373 (void *)reg_value,
1374 p_rem_nfcipinfo->NFCID_Length);
1375 (void)memcpy((void *)p_nfcipinfo->nfcid3t,
1376 (void *)reg_value,
1377 reg_length);
1378 if ((NULL != psHciContext->p_target_info) &&
1379 (NFCIP_TARGET == p_nfcipinfo->nfcip_type))
1380 {
1381 phHal_sNfcIPInfo_t *p_remtgt_info = NULL;
1382 /* This is given to user */
1383 p_remtgt_info =
1384 &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
1385 p_remtgt_info->NFCID_Length = reg_length;
1386 (void)memcpy((void *)p_remtgt_info->NFCID,
1387 (void *)reg_value,
1388 p_remtgt_info->NFCID_Length);
1389 }
1390 }
1391 else
1392 {
1393 status = PHNFCSTVAL(CID_NFC_HCI,
1394 NFCSTATUS_INVALID_HCI_RESPONSE);
1395 }
1396 break;
1397 }
1398 case NXP_NFCIP_PARAM:
1399 {
1400 if (sizeof(*reg_value) == reg_length)
1401 {
1402 HCI_PRINT_BUFFER("\tNFCIP PARAMS", reg_value, reg_length);
1403 p_nfcipinfo->initiator_speed = (phHciNfc_eP2PSpeed_t)
1404 ((*reg_value >> NFCIP_COMM_INITIATOR_SHIFT)
1405 & NFCIP_COMM_FACTOR);
1406 p_nfcipinfo->target_speed = (phHciNfc_eP2PSpeed_t)
1407 (*reg_value & NFCIP_COMM_FACTOR);
1408 p_nfcipinfo->max_frame_len = NFCIP_DATA_RATE_CALC(*reg_value);
1409
1410 if (NULL != psHciContext->p_target_info)
1411 {
1412 phHal_sNfcIPInfo_t *p_remtgt_info = NULL;
1413 /* This is given to user */
1414 p_remtgt_info =
1415 &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
1416 p_remtgt_info->MaxFrameLength = p_nfcipinfo->max_frame_len;
1417 p_remtgt_info->Nfcip_Datarate = (phHalNfc_eDataRate_t)
1418 p_nfcipinfo->initiator_speed;
1419 }
1420 }
1421 else
1422 {
1423 status = PHNFCSTVAL(CID_NFC_HCI,
1424 NFCSTATUS_INVALID_HCI_RESPONSE);
1425 }
1426 break;
1427 }
1428 case NXP_NFCIP_MODE:
1429 {
1430 if (sizeof(*reg_value) == reg_length)
1431 {
1432 HCI_PRINT_BUFFER("\tNFCIP MODE", reg_value, reg_length);
1433 p_nfcipinfo->nfcip_mode = *reg_value;
1434 }
1435 else
1436 {
1437 status = PHNFCSTVAL(CID_NFC_HCI,
1438 NFCSTATUS_INVALID_HCI_RESPONSE);
1439 }
1440 break;
1441 }
1442 case NXP_NFCIP_ATR_REQ:
1443 {
1444 if (reg_length <= NFCIP_ATR_MAX_LENGTH)
1445 {
1446 HCI_PRINT_BUFFER("\tNFCIP ATR_REQ", reg_value, reg_length);
1447 p_rem_nfcipinfo->ATRInfo_Length =
1448 p_nfcipinfo->atr_req_length = reg_length;
1449 (void)memcpy((void *)p_rem_nfcipinfo->ATRInfo,
1450 (void *)reg_value,
1451 p_rem_nfcipinfo->ATRInfo_Length);
1452 (void)memcpy((void *)p_nfcipinfo->atr_req_info,
1453 (void *)reg_value,
1454 p_nfcipinfo->atr_req_length);
1455 if (NULL != psHciContext->p_target_info)
1456 {
1457 phHal_sNfcIPInfo_t *p_remtgt_info = NULL;
1458 /* This is given to user */
1459 p_remtgt_info =
1460 &(psHciContext->p_target_info->RemoteDevInfo.NfcIP_Info);
1461 p_remtgt_info->NFCID_Length = reg_length;
1462 (void)memcpy((void *)p_remtgt_info->ATRInfo,
1463 (void *)reg_value,
1464 p_remtgt_info->ATRInfo_Length);
1465 }
1466 }
1467 else
1468 {
1469 status = PHNFCSTVAL(CID_NFC_HCI,
1470 NFCSTATUS_INVALID_HCI_RESPONSE);
1471 }
1472 break;
1473 }
1474 case NXP_NFCIP_PSL1:
1475 {
1476 if (sizeof(*reg_value) == reg_length)
1477 {
1478 HCI_PRINT_BUFFER("\tNFCIP PSL1", reg_value, reg_length);
1479 p_nfcipinfo->psl1 = *reg_value;
1480 }
1481 else
1482 {
1483 status = PHNFCSTVAL(CID_NFC_HCI,
1484 NFCSTATUS_INVALID_HCI_RESPONSE);
1485 }
1486 break;
1487 }
1488 case NXP_NFCIP_PSL2:
1489 {
1490 if (sizeof(*reg_value) == reg_length)
1491 {
1492 HCI_PRINT_BUFFER("\tNFCIP PSL2", reg_value, reg_length);
1493 p_nfcipinfo->psl2 = *reg_value;
1494 }
1495 else
1496 {
1497 status = PHNFCSTVAL(CID_NFC_HCI,
1498 NFCSTATUS_INVALID_HCI_RESPONSE);
1499 }
1500 break;
1501 }
1502 case NXP_NFCIP_DID:
1503 {
1504 if (sizeof(*reg_value) == reg_length)
1505 {
1506 HCI_PRINT_BUFFER("\tNFCIP DID", reg_value, reg_length);
1507 p_nfcipinfo->did = *reg_value;
1508 }
1509 else
1510 {
1511 status = PHNFCSTVAL(CID_NFC_HCI,
1512 NFCSTATUS_INVALID_HCI_RESPONSE);
1513 }
1514 break;
1515 }
1516 case NXP_NFCIP_NAD:
1517 {
1518 if (sizeof(*reg_value) == reg_length)
1519 {
1520 HCI_PRINT_BUFFER("\tNFCIP NAD", reg_value, reg_length);
1521 p_nfcipinfo->nad = *reg_value;
1522 }
1523 else
1524 {
1525 status = PHNFCSTVAL(CID_NFC_HCI,
1526 NFCSTATUS_INVALID_HCI_RESPONSE);
1527 }
1528 break;
1529 }
1530 case NXP_NFCIP_OPTIONS:
1531 {
1532 if (sizeof(*reg_value) == reg_length)
1533 {
1534 HCI_PRINT_BUFFER("\tNFCIP OPTIONS", reg_value, reg_length);
1535 p_nfcipinfo->options = *reg_value;
1536 }
1537 else
1538 {
1539 status = PHNFCSTVAL(CID_NFC_HCI,
1540 NFCSTATUS_INVALID_HCI_RESPONSE);
1541 }
1542 break;
1543 }
1544 default:
1545 {
1546 status = PHNFCSTVAL(CID_NFC_HCI,
1547 NFCSTATUS_INVALID_HCI_RESPONSE);
1548 break;
1549 }
1550 }
1551 return status;
1552 }
1553
1554
1555 NFCSTATUS
phHciNfc_NfcIP_SetMode(phHciNfc_sContext_t * psHciContext,void * pHwRef,phHciNfc_eNfcIPType_t nfciptype,uint8_t nfcip_mode)1556 phHciNfc_NfcIP_SetMode(
1557 phHciNfc_sContext_t *psHciContext,
1558 void *pHwRef,
1559 phHciNfc_eNfcIPType_t nfciptype,
1560 uint8_t nfcip_mode
1561 )
1562 {
1563 NFCSTATUS status = NFCSTATUS_SUCCESS;
1564
1565 if( (NULL == psHciContext) || (NULL == pHwRef) ||
1566 (nfcip_mode > (uint8_t)NFCIP_MODE_ALL))
1567 {
1568 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1569 }
1570 else if (NFCIP_INVALID == nfciptype)
1571 {
1572 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
1573 }
1574 else if(NULL == psHciContext->p_nfcip_info)
1575 {
1576 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1577 }
1578 else
1579 {
1580 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
1581 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
1582 uint8_t pipeid = 0;
1583
1584 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
1585 psHciContext->p_nfcip_info ;
1586 p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
1587 p_nfcipinfo->p_init_pipe_info:
1588 p_nfcipinfo->p_tgt_pipe_info);
1589
1590 if(NULL == p_pipe_info )
1591 {
1592 status = PHNFCSTVAL(CID_NFC_HCI,
1593 NFCSTATUS_INVALID_HCI_INFORMATION);
1594 }
1595 else
1596 {
1597 pipeid = p_pipe_info->pipe.pipe_id ;
1598 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_MODE;
1599
1600 p_pipe_info->param_info = &nfcip_mode;
1601 p_pipe_info->param_length = sizeof(uint8_t);
1602 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1603 pipeid, (uint8_t)ANY_SET_PARAMETER);
1604 }
1605 }
1606 return status;
1607 }
1608
1609 NFCSTATUS
phHciNfc_NfcIP_SetNAD(phHciNfc_sContext_t * psHciContext,void * pHwRef,phHciNfc_eNfcIPType_t nfciptype,uint8_t nad)1610 phHciNfc_NfcIP_SetNAD(
1611 phHciNfc_sContext_t *psHciContext,
1612 void *pHwRef,
1613 phHciNfc_eNfcIPType_t nfciptype,
1614 uint8_t nad
1615 )
1616 {
1617 NFCSTATUS status = NFCSTATUS_SUCCESS;
1618
1619 if( (NULL == psHciContext) || (NULL == pHwRef))
1620 {
1621 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1622 }
1623 else if (NFCIP_INVALID == nfciptype)
1624 {
1625 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
1626 }
1627 else if(NULL == psHciContext->p_nfcip_info)
1628 {
1629 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1630 }
1631 else
1632 {
1633 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
1634 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
1635 uint8_t pipeid = 0;
1636
1637 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
1638 psHciContext->p_nfcip_info ;
1639 p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
1640 p_nfcipinfo->p_init_pipe_info:
1641 p_nfcipinfo->p_tgt_pipe_info);
1642
1643 if(NULL == p_pipe_info )
1644 {
1645 status = PHNFCSTVAL(CID_NFC_HCI,
1646 NFCSTATUS_INVALID_HCI_INFORMATION);
1647 }
1648 else
1649 {
1650 pipeid = p_pipe_info->pipe.pipe_id ;
1651 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_NAD;
1652
1653 p_pipe_info->param_info = &nad;
1654 p_pipe_info->param_length = sizeof(uint8_t);
1655 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1656 pipeid, (uint8_t)ANY_SET_PARAMETER);
1657 }
1658 }
1659 return status;
1660 }
1661
1662 NFCSTATUS
phHciNfc_NfcIP_SetDID(phHciNfc_sContext_t * psHciContext,void * pHwRef,uint8_t did)1663 phHciNfc_NfcIP_SetDID(
1664 phHciNfc_sContext_t *psHciContext,
1665 void *pHwRef,
1666 uint8_t did
1667 )
1668 {
1669 NFCSTATUS status = NFCSTATUS_SUCCESS;
1670
1671 if( (NULL == psHciContext) || (NULL == pHwRef))
1672 {
1673 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1674 }
1675 else if(NULL == psHciContext->p_nfcip_info)
1676 {
1677 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1678 }
1679 else
1680 {
1681 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
1682 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
1683 uint8_t pipeid = 0;
1684
1685 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
1686 psHciContext->p_nfcip_info ;
1687 p_pipe_info = p_nfcipinfo->p_init_pipe_info;
1688
1689 if(NULL == p_pipe_info )
1690 {
1691 status = PHNFCSTVAL(CID_NFC_HCI,
1692 NFCSTATUS_INVALID_HCI_INFORMATION);
1693 }
1694 else
1695 {
1696 pipeid = p_pipe_info->pipe.pipe_id ;
1697 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_DID;
1698
1699 p_pipe_info->param_info = &did;
1700 p_pipe_info->param_length = sizeof(uint8_t);
1701 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1702 pipeid, (uint8_t)ANY_SET_PARAMETER);
1703 }
1704 }
1705 return status;
1706 }
1707
1708 NFCSTATUS
phHciNfc_NfcIP_SetOptions(phHciNfc_sContext_t * psHciContext,void * pHwRef,phHciNfc_eNfcIPType_t nfciptype,uint8_t nfcip_options)1709 phHciNfc_NfcIP_SetOptions(
1710 phHciNfc_sContext_t *psHciContext,
1711 void *pHwRef,
1712 phHciNfc_eNfcIPType_t nfciptype,
1713 uint8_t nfcip_options
1714 )
1715 {
1716 NFCSTATUS status = NFCSTATUS_SUCCESS;
1717
1718 if( (NULL == psHciContext) || (NULL == pHwRef))
1719 {
1720 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1721 }
1722 else if (NFCIP_INVALID == nfciptype)
1723 {
1724 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
1725 }
1726 else if(NULL == psHciContext->p_nfcip_info)
1727 {
1728 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1729 }
1730 else
1731 {
1732 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
1733 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
1734 uint8_t pipeid = 0;
1735
1736 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
1737 psHciContext->p_nfcip_info ;
1738 p_pipe_info = ((NFCIP_INITIATOR == p_nfcipinfo->nfcip_type)?
1739 p_nfcipinfo->p_init_pipe_info:
1740 p_nfcipinfo->p_tgt_pipe_info);
1741 pipeid = p_pipe_info->pipe.pipe_id ;
1742 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_OPTIONS;
1743
1744 p_pipe_info->param_info = &nfcip_options;
1745 p_pipe_info->param_length = sizeof(uint8_t);
1746 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1747 pipeid, (uint8_t)ANY_SET_PARAMETER);
1748 }
1749 return status;
1750 }
1751
1752 NFCSTATUS
phHciNfc_NfcIP_SetATRInfo(phHciNfc_sContext_t * psHciContext,void * pHwRef,phHciNfc_eNfcIPType_t nfciptype,phHal_sNfcIPCfg_t * atr_info)1753 phHciNfc_NfcIP_SetATRInfo(
1754 phHciNfc_sContext_t *psHciContext,
1755 void *pHwRef,
1756 phHciNfc_eNfcIPType_t nfciptype,
1757 phHal_sNfcIPCfg_t *atr_info
1758 )
1759 {
1760 NFCSTATUS status = NFCSTATUS_SUCCESS;
1761
1762 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == atr_info) ||
1763 (atr_info->generalBytesLength > NFCIP_ATR_MAX_LENGTH))
1764 {
1765 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1766 }
1767 else if (NFCIP_INVALID == nfciptype)
1768 {
1769 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
1770 }
1771 else if(NULL == psHciContext->p_nfcip_info)
1772 {
1773 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1774 }
1775 else
1776 {
1777 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
1778 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
1779 uint8_t pipeid = 0;
1780
1781 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
1782 psHciContext->p_nfcip_info ;
1783 p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
1784 p_nfcipinfo->p_init_pipe_info:
1785 p_nfcipinfo->p_tgt_pipe_info);
1786
1787 if(NULL == p_pipe_info )
1788 {
1789 status = PHNFCSTVAL(CID_NFC_HCI,
1790 NFCSTATUS_INVALID_HCI_INFORMATION);
1791 }
1792 else
1793 {
1794 pipeid = p_pipe_info->pipe.pipe_id ;
1795 p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR == nfciptype)?
1796 NXP_NFCIP_ATR_REQ :
1797 NXP_NFCIP_ATR_RES);
1798
1799 p_pipe_info->param_info = atr_info->generalBytes;
1800 p_pipe_info->param_length = (uint8_t)
1801 atr_info->generalBytesLength;
1802 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1803 pipeid, (uint8_t)ANY_SET_PARAMETER);
1804 }
1805 }
1806 return status;
1807 }
1808
1809 NFCSTATUS
phHciNfc_NfcIP_SetPSL1(phHciNfc_sContext_t * psHciContext,void * pHwRef,uint8_t psl1)1810 phHciNfc_NfcIP_SetPSL1(
1811 phHciNfc_sContext_t *psHciContext,
1812 void *pHwRef,
1813 uint8_t psl1
1814 )
1815 {
1816 NFCSTATUS status = NFCSTATUS_SUCCESS;
1817
1818 if( (NULL == psHciContext) || (NULL == pHwRef))
1819 {
1820 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1821 }
1822 else if(NULL == psHciContext->p_nfcip_info)
1823 {
1824 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1825 }
1826 else
1827 {
1828 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
1829 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
1830 uint8_t pipeid = 0;
1831
1832 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
1833 psHciContext->p_nfcip_info ;
1834 p_pipe_info = p_nfcipinfo->p_init_pipe_info;
1835
1836 if(NULL == p_pipe_info )
1837 {
1838 status = PHNFCSTVAL(CID_NFC_HCI,
1839 NFCSTATUS_INVALID_HCI_INFORMATION);
1840 }
1841 else
1842 {
1843 pipeid = p_pipe_info->pipe.pipe_id ;
1844 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PSL1;
1845
1846 p_pipe_info->param_info = &psl1;
1847 p_pipe_info->param_length = sizeof(uint8_t);
1848 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1849 pipeid, (uint8_t)ANY_SET_PARAMETER);
1850 }
1851 }
1852 return status;
1853 }
1854
1855 NFCSTATUS
phHciNfc_NfcIP_SetPSL2(phHciNfc_sContext_t * psHciContext,void * pHwRef,uint8_t psl2)1856 phHciNfc_NfcIP_SetPSL2(
1857 phHciNfc_sContext_t *psHciContext,
1858 void *pHwRef,
1859 uint8_t psl2
1860 )
1861 {
1862 NFCSTATUS status = NFCSTATUS_SUCCESS;
1863
1864 if( (NULL == psHciContext) || (NULL == pHwRef))
1865 {
1866 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1867 }
1868 else if(NULL == psHciContext->p_nfcip_info)
1869 {
1870 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1871 }
1872 else
1873 {
1874 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
1875 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
1876 uint8_t pipeid = 0;
1877
1878 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
1879 psHciContext->p_nfcip_info ;
1880 p_pipe_info = p_nfcipinfo->p_init_pipe_info;
1881
1882 if(NULL == p_pipe_info )
1883 {
1884 status = PHNFCSTVAL(CID_NFC_HCI,
1885 NFCSTATUS_INVALID_HCI_INFORMATION);
1886 }
1887 else
1888 {
1889 pipeid = p_pipe_info->pipe.pipe_id ;
1890 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PSL2;
1891
1892 p_pipe_info->param_info = &psl2;
1893 p_pipe_info->param_length = sizeof(uint8_t);
1894 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1895 pipeid, (uint8_t)ANY_SET_PARAMETER);
1896 }
1897 }
1898 return status;
1899 }
1900
1901 NFCSTATUS
phHciNfc_NfcIP_GetStatus(phHciNfc_sContext_t * psHciContext,void * pHwRef,phHciNfc_eNfcIPType_t nfciptype)1902 phHciNfc_NfcIP_GetStatus(
1903 phHciNfc_sContext_t *psHciContext,
1904 void *pHwRef,
1905 phHciNfc_eNfcIPType_t nfciptype
1906 )
1907 {
1908 NFCSTATUS status = NFCSTATUS_SUCCESS;
1909
1910 if( (NULL == psHciContext) || (NULL == pHwRef))
1911 {
1912 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1913 }
1914 else if (NFCIP_INVALID == nfciptype)
1915 {
1916 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
1917 }
1918 else if(NULL == psHciContext->p_nfcip_info)
1919 {
1920 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1921 }
1922 else
1923 {
1924 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
1925 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
1926 uint8_t pipeid = 0;
1927
1928 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
1929 psHciContext->p_nfcip_info ;
1930 p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
1931 p_nfcipinfo->p_init_pipe_info :
1932 p_nfcipinfo->p_tgt_pipe_info);
1933 if(NULL == p_pipe_info )
1934 {
1935 status = PHNFCSTVAL(CID_NFC_HCI,
1936 NFCSTATUS_INVALID_HCI_INFORMATION);
1937 }
1938 else
1939 {
1940 pipeid = p_pipe_info->pipe.pipe_id ;
1941 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_STATUS;
1942
1943 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1944 pipeid, (uint8_t)ANY_GET_PARAMETER);
1945 }
1946 }
1947 return status;
1948 }
1949
1950 NFCSTATUS
phHciNfc_NfcIP_GetParam(phHciNfc_sContext_t * psHciContext,void * pHwRef,phHciNfc_eNfcIPType_t nfciptype)1951 phHciNfc_NfcIP_GetParam(
1952 phHciNfc_sContext_t *psHciContext,
1953 void *pHwRef,
1954 phHciNfc_eNfcIPType_t nfciptype
1955 )
1956 {
1957 NFCSTATUS status = NFCSTATUS_SUCCESS;
1958
1959 if( (NULL == psHciContext) || (NULL == pHwRef))
1960 {
1961 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
1962 }
1963 else if (NFCIP_INVALID == nfciptype)
1964 {
1965 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
1966 }
1967 else if(NULL == psHciContext->p_nfcip_info)
1968 {
1969 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
1970 }
1971 else
1972 {
1973 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
1974 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
1975 uint8_t pipeid = 0;
1976
1977 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
1978 psHciContext->p_nfcip_info ;
1979 p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
1980 p_nfcipinfo->p_init_pipe_info :
1981 p_nfcipinfo->p_tgt_pipe_info);
1982 if(NULL == p_pipe_info )
1983 {
1984 status = PHNFCSTVAL(CID_NFC_HCI,
1985 NFCSTATUS_INVALID_HCI_INFORMATION);
1986 }
1987 else
1988 {
1989 pipeid = p_pipe_info->pipe.pipe_id ;
1990 p_pipe_info->reg_index = (uint8_t)NXP_NFCIP_PARAM;
1991
1992 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
1993 pipeid, (uint8_t)ANY_GET_PARAMETER);
1994 }
1995 }
1996 return status;
1997 }
1998
1999 NFCSTATUS
phHciNfc_Initiator_Cont_Activate(phHciNfc_sContext_t * psHciContext,void * pHwRef)2000 phHciNfc_Initiator_Cont_Activate (
2001 phHciNfc_sContext_t *psHciContext,
2002 void *pHwRef
2003 )
2004 {
2005 NFCSTATUS status = NFCSTATUS_SUCCESS;
2006
2007 if( (NULL == psHciContext) || (NULL == pHwRef) )
2008 {
2009 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
2010 }
2011 else if(NULL == psHciContext->p_nfcip_info)
2012 {
2013 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
2014 }
2015 else
2016 {
2017 phHciNfc_NfcIP_Info_t *p_nfcipinfo = NULL;
2018 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
2019
2020 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
2021 psHciContext->p_nfcip_info ;
2022 p_nfcipinfo->nfcip_type = NFCIP_INITIATOR;
2023 psHciContext->host_rf_type = phHal_eNfcIP1_Initiator;
2024 p_pipe_info = p_nfcipinfo->p_init_pipe_info;
2025 if(NULL == p_pipe_info )
2026 {
2027 status = PHNFCSTVAL(CID_NFC_HCI,
2028 NFCSTATUS_INVALID_HCI_INFORMATION);
2029 }
2030 else
2031 {
2032 phHciNfc_HCP_Packet_t *hcp_packet = NULL;
2033 uint16_t length = HCP_HEADER_LEN;
2034 uint8_t pipeid = 0;
2035
2036 pipeid = p_pipe_info->pipe.pipe_id;
2037 psHciContext->tx_total = 0 ;
2038 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
2039 /* Construct the HCP Frame */
2040 phHciNfc_Build_HCPFrame(hcp_packet,(uint8_t)HCP_CHAINBIT_DEFAULT,
2041 (uint8_t) pipeid, (uint8_t)HCP_MSG_TYPE_COMMAND,
2042 (uint8_t)NXP_NFCI_CONTINUE_ACTIVATION);
2043
2044 p_pipe_info->sent_msg_type = (uint8_t)HCP_MSG_TYPE_COMMAND;
2045 p_pipe_info->prev_msg = (uint8_t)NXP_NFCI_CONTINUE_ACTIVATION;
2046 psHciContext->tx_total = length;
2047 psHciContext->response_pending = (uint8_t)TRUE;
2048
2049 /* Send the Constructed HCP packet to the lower layer */
2050 status = phHciNfc_Send_HCP( psHciContext, pHwRef);
2051 p_pipe_info->prev_status = status;
2052 }
2053 }
2054 return status;
2055 }
2056
2057
2058 NFCSTATUS
phHciNfc_NfcIP_GetATRInfo(phHciNfc_sContext_t * psHciContext,void * pHwRef,phHciNfc_eNfcIPType_t nfciptype)2059 phHciNfc_NfcIP_GetATRInfo (
2060 phHciNfc_sContext_t *psHciContext,
2061 void *pHwRef,
2062 phHciNfc_eNfcIPType_t nfciptype
2063 )
2064 {
2065 NFCSTATUS status = NFCSTATUS_SUCCESS;
2066
2067 if( (NULL == psHciContext)
2068 || (NULL == pHwRef))
2069 {
2070 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
2071 }
2072 else if (NFCIP_INVALID == nfciptype)
2073 {
2074 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
2075 }
2076 else if(NULL == psHciContext->p_nfcip_info)
2077 {
2078 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
2079 }
2080 else
2081 {
2082 phHciNfc_NfcIP_Info_t *p_nfcipinfo=NULL;
2083 phHciNfc_Pipe_Info_t *p_pipe_info=NULL;
2084 uint8_t pipeid = 0;
2085
2086 p_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
2087 psHciContext->p_nfcip_info ;
2088
2089 p_pipe_info = ((NFCIP_INITIATOR == nfciptype)?
2090 p_nfcipinfo->p_init_pipe_info :
2091 p_nfcipinfo->p_tgt_pipe_info);
2092
2093 if(NULL == p_pipe_info )
2094 {
2095 status = PHNFCSTVAL(CID_NFC_HCI,
2096 NFCSTATUS_INVALID_HCI_INFORMATION);
2097 }
2098 else
2099 {
2100 p_pipe_info->reg_index = (uint8_t)((NFCIP_INITIATOR == nfciptype)?
2101 NXP_NFCIP_ATR_RES :
2102 NXP_NFCIP_ATR_REQ);
2103 pipeid = p_pipe_info->pipe.pipe_id ;
2104 /* Fill the data buffer and send the command to the
2105 device */
2106 status =
2107 phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
2108 pipeid, (uint8_t)ANY_GET_PARAMETER);
2109 }
2110 }
2111 return status;
2112 }
2113
2114 NFCSTATUS
phHciNfc_NfcIP_SetMergeSak(phHciNfc_sContext_t * psHciContext,void * pHwRef,uint8_t sak_value)2115 phHciNfc_NfcIP_SetMergeSak(
2116 phHciNfc_sContext_t *psHciContext,
2117 void *pHwRef,
2118 uint8_t sak_value
2119 )
2120 {
2121 NFCSTATUS status = NFCSTATUS_SUCCESS;
2122
2123 if( (NULL == psHciContext) || (NULL == pHwRef) ||
2124 (sak_value > (uint8_t)TRUE))
2125 {
2126 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
2127 }
2128 else if(NULL == psHciContext->p_nfcip_info)
2129 {
2130 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
2131 }
2132 else
2133 {
2134 phHciNfc_NfcIP_Info_t *ps_nfcipinfo=NULL;
2135 phHciNfc_Pipe_Info_t *ps_pipe_info=NULL;
2136 uint8_t pipeid = 0;
2137
2138 ps_nfcipinfo = (phHciNfc_NfcIP_Info_t *)
2139 psHciContext->p_nfcip_info ;
2140 ps_pipe_info = ps_nfcipinfo->p_tgt_pipe_info;
2141
2142 if(NULL == ps_pipe_info )
2143 {
2144 status = PHNFCSTVAL(CID_NFC_HCI,
2145 NFCSTATUS_INVALID_HCI_INFORMATION);
2146 }
2147 else
2148 {
2149 pipeid = ps_pipe_info->pipe.pipe_id ;
2150 ps_pipe_info->reg_index = (uint8_t)NXP_NFCIP_MERGE;
2151
2152 ps_pipe_info->param_info = &sak_value;
2153 ps_pipe_info->param_length = sizeof(uint8_t);
2154 status = phHciNfc_Send_Generic_Cmd( psHciContext, pHwRef,
2155 pipeid, (uint8_t)ANY_SET_PARAMETER);
2156 }
2157 }
2158 return status;
2159 }
2160
2161 #endif /* #if defined (ENABLE_P2P) */
2162
2163