1 /*
2 * Copyright (C) 2010 NXP Semiconductors
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 /*!
18 * =========================================================================== *
19 * *
20 * *
21 * \file phHciNfc_SWP.c *
22 * \brief HCI SWP gate Management Routines. *
23 * *
24 * *
25 * Project: NFC-FRI-1.1 *
26 * *
27 * $Date: Tue Aug 18 10:16:36 2009 $ *
28 * $Author: ing04880 $ *
29 * $Revision: 1.31 $ *
30 * $Aliases: NFC_FRI1.1_WK934_R31_1,NFC_FRI1.1_WK941_PREP1,NFC_FRI1.1_WK941_PREP2,NFC_FRI1.1_WK941_1,NFC_FRI1.1_WK943_R32_1,NFC_FRI1.1_WK949_PREP1,NFC_FRI1.1_WK943_R32_10,NFC_FRI1.1_WK943_R32_13,NFC_FRI1.1_WK943_R32_14,NFC_FRI1.1_WK1007_R33_1,NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $ * *
31 * =========================================================================== *
32 */
33
34 /*
35 ***************************** Header File Inclusion ****************************
36 */
37 #include <phNfcCompId.h>
38 #include <phHciNfc_Pipe.h>
39 #include <phHciNfc_SWP.h>
40 #include <phOsalNfc.h>
41 #include <phHciNfc_Emulation.h>
42 #include <phHciNfc_DevMgmt.h>
43 /*
44 ****************************** Macro Definitions *******************************
45 */
46
47 /* SWP Gate regsitry Settings */
48 /* set default mode mode as virtual mode */
49 #define NXP_SWP_DEFAULT_MODE_INDEX (0x01U)
50 /* Get the Status of the UICC Connection */
51 #define NXP_SWP_STATUS_INDEX (0x02U)
52
53 /* Configure the Secure Element Protected Mode */
54 #define NXP_SWP_PROTECTED_INDEX (0x03U)
55
56 /* Switch mode index */
57 #define NXP_EVT_SWP_SWITCH_MODE (0x03U)
58
59 /* Protected Event from the Host Controller */
60 #define NXP_EVT_SWP_PROTECTED (0x04U)
61
62 /****************** Structure and Enumeration ****************************/
63
64 /****************** Static Function Declaration **************************/
65
66 static
67 NFCSTATUS
68 phHciNfc_Recv_SWP_Response(
69 void *psContext,
70 void *pHwRef,
71 uint8_t *pResponse,
72 #ifdef ONE_BYTE_LEN
73 uint8_t length
74 #else
75 uint16_t length
76 #endif
77 );
78
79 static
80 NFCSTATUS
81 phHciNfc_Send_SWP_Event(
82 phHciNfc_sContext_t *psHciContext,
83 void *pHwRef,
84 uint8_t pipe_id,
85 uint8_t event
86 );
87
88
89 static
90 NFCSTATUS
91 phHciNfc_Recv_SWP_Event(
92 void *psContext,
93 void *pHwRef,
94 uint8_t *pEvent,
95 #ifdef ONE_BYTE_LEN
96 uint8_t length
97 #else
98 uint16_t length
99 #endif
100 );
101
102 static
103 NFCSTATUS
104 phHciNfc_SWP_InfoUpdate(
105 phHciNfc_sContext_t *psHciContext,
106 uint8_t index,
107 uint8_t *reg_value,
108 uint8_t reg_length
109 );
110
111 /*
112 *************************** Function Definitions ***************************
113 */
114
115 NFCSTATUS
phHciNfc_SWP_Get_PipeID(phHciNfc_sContext_t * psHciContext,uint8_t * ppipe_id)116 phHciNfc_SWP_Get_PipeID(
117 phHciNfc_sContext_t *psHciContext,
118 uint8_t *ppipe_id
119 )
120 {
121 NFCSTATUS status = NFCSTATUS_SUCCESS;
122
123 if( (NULL != psHciContext)
124 && ( NULL != ppipe_id )
125 && ( NULL != psHciContext->p_swp_info )
126 )
127 {
128 phHciNfc_SWP_Info_t *p_swp_info=NULL;
129 p_swp_info = (phHciNfc_SWP_Info_t *)
130 psHciContext->p_swp_info ;
131 *ppipe_id = p_swp_info->pipe_id ;
132 }
133 else
134 {
135 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
136 }
137 return status;
138 }
139
140 NFCSTATUS
phHciNfc_SWP_Init_Resources(phHciNfc_sContext_t * psHciContext)141 phHciNfc_SWP_Init_Resources(phHciNfc_sContext_t *psHciContext)
142 {
143 NFCSTATUS status = NFCSTATUS_SUCCESS;
144 phHciNfc_SWP_Info_t *ps_swp_info=NULL;
145
146 if( NULL == psHciContext )
147 {
148 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
149 }
150 else
151 {
152 if(( NULL == psHciContext->p_swp_info ) &&
153 (phHciNfc_Allocate_Resource((void **)(&ps_swp_info),
154 sizeof(phHciNfc_SWP_Info_t))== NFCSTATUS_SUCCESS))
155 {
156 psHciContext->p_swp_info = ps_swp_info;
157 ps_swp_info->current_seq = SWP_INVALID_SEQUENCE;
158 ps_swp_info->next_seq = SWP_INVALID_SEQUENCE;
159 ps_swp_info->pipe_id = (uint8_t)HCI_UNKNOWN_PIPE_ID;
160 }
161 else
162 {
163 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INSUFFICIENT_RESOURCES);
164 }
165
166 }
167 return status;
168 }
169
170
171 NFCSTATUS
phHciNfc_SWP_Update_PipeInfo(phHciNfc_sContext_t * psHciContext,uint8_t pipeID,phHciNfc_Pipe_Info_t * pPipeInfo)172 phHciNfc_SWP_Update_PipeInfo(
173 phHciNfc_sContext_t *psHciContext,
174 uint8_t pipeID,
175 phHciNfc_Pipe_Info_t *pPipeInfo
176 )
177 {
178 NFCSTATUS status = NFCSTATUS_SUCCESS;
179
180 if( NULL == psHciContext )
181 {
182 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
183 }
184 else if(NULL == psHciContext->p_swp_info)
185 {
186 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
187 }
188 else
189 {
190 phHciNfc_SWP_Info_t *ps_swp_info=NULL;
191 ps_swp_info = (phHciNfc_SWP_Info_t *)
192 psHciContext->p_swp_info ;
193 /* Update the pipe_id of the SWP Gate obtained from HCI Response */
194 ps_swp_info->pipe_id = pipeID;
195 ps_swp_info->p_pipe_info = pPipeInfo;
196 if (NULL != pPipeInfo)
197 {
198 /* Update the Response Receive routine of the SWP Gate */
199 pPipeInfo->recv_resp = &phHciNfc_Recv_SWP_Response;
200 pPipeInfo->recv_event =&phHciNfc_Recv_SWP_Event;
201 }
202 }
203 return status;
204 }
205
206
207 static
208 NFCSTATUS
phHciNfc_Recv_SWP_Response(void * psContext,void * pHwRef,uint8_t * pResponse,uint8_t length)209 phHciNfc_Recv_SWP_Response(
210 void *psContext,
211 void *pHwRef,
212 uint8_t *pResponse,
213 #ifdef ONE_BYTE_LEN
214 uint8_t length
215 #else
216 uint16_t length
217 #endif
218 )
219 {
220 NFCSTATUS status = NFCSTATUS_SUCCESS;
221 phHciNfc_sContext_t *psHciContext =
222 (phHciNfc_sContext_t *)psContext ;
223
224
225 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pResponse)
226 || (length == 0))
227 {
228 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
229 }
230 else if(NULL == psHciContext->p_swp_info)
231 {
232 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
233 }
234 else
235 {
236 phHciNfc_SWP_Info_t *ps_swp_info=NULL;
237 uint8_t prev_cmd = ANY_GET_PARAMETER;
238
239 ps_swp_info = (phHciNfc_SWP_Info_t *)
240 psHciContext->p_swp_info ;
241 if( NULL == ps_swp_info->p_pipe_info)
242 {
243 status = PHNFCSTVAL(CID_NFC_HCI,
244 NFCSTATUS_INVALID_HCI_INFORMATION);
245 }
246 else
247 {
248 prev_cmd = ps_swp_info->p_pipe_info->prev_msg ;
249 switch(prev_cmd)
250 {
251 case ANY_GET_PARAMETER:
252 {
253 HCI_PRINT(" Getting the SWP Parameter \n");
254 status = phHciNfc_SWP_InfoUpdate(psHciContext,
255 ps_swp_info->p_pipe_info->reg_index,
256 &pResponse[HCP_HEADER_LEN],
257 (uint8_t)(length - HCP_HEADER_LEN));
258
259 break;
260 }
261 case ANY_SET_PARAMETER:
262 {
263 HCI_PRINT("SWP Parameter Set \n");
264 break;
265 }
266 case ANY_OPEN_PIPE:
267 {
268 HCI_PRINT("SWP gate open pipe complete\n");
269 break;
270 }
271 case ANY_CLOSE_PIPE:
272 {
273 HCI_PRINT("SWP close pipe complete\n");
274 break;
275 }
276 default:
277 {
278 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
279 break;
280 }
281 }
282 if( NFCSTATUS_SUCCESS == status )
283 {
284 status = phHciNfc_EmuMgmt_Update_Seq(psHciContext,
285 UPDATE_SEQ);
286 ps_swp_info->p_pipe_info->prev_status = NFCSTATUS_SUCCESS;
287 ps_swp_info->current_seq = ps_swp_info->next_seq;
288 }
289 }
290 }
291 return status;
292 }
293
294
295 NFCSTATUS
phHciNfc_SWP_Configure_Default(void * psHciHandle,void * pHwRef,uint8_t enable_type)296 phHciNfc_SWP_Configure_Default(
297 void *psHciHandle,
298 void *pHwRef,
299 uint8_t enable_type
300 )
301 {
302 NFCSTATUS status = NFCSTATUS_SUCCESS;
303 static uint8_t param = 0 ;
304 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
305
306 if((NULL == psHciContext)||(NULL == pHwRef))
307 {
308 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
309 }
310 else if(NULL == psHciContext->p_swp_info)
311 {
312 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
313 }
314 else
315 {
316 phHciNfc_SWP_Info_t *ps_swp_info=NULL;
317 phHciNfc_Pipe_Info_t *ps_pipe_info=NULL;
318
319 ps_swp_info = (phHciNfc_SWP_Info_t*)psHciContext->p_swp_info;
320 ps_pipe_info = ps_swp_info->p_pipe_info;
321
322 if(NULL == ps_pipe_info)
323 {
324 status = PHNFCSTVAL(CID_NFC_HCI,
325 NFCSTATUS_INVALID_HCI_INFORMATION);
326 }
327 else
328 {
329 ps_pipe_info->reg_index = NXP_SWP_DEFAULT_MODE_INDEX;
330 /* Enable/Disable SWP link */
331 param = (uint8_t)enable_type;
332 ps_pipe_info->param_info =(void*)¶m ;
333 ps_pipe_info->param_length = sizeof(param) ;
334 status = phHciNfc_Send_Generic_Cmd(psHciContext, pHwRef,
335 ps_swp_info->pipe_id,
336 (uint8_t)ANY_SET_PARAMETER);
337 }
338
339 }
340 return status;
341 }
342
343
344 NFCSTATUS
phHciNfc_SWP_Get_Status(void * psHciHandle,void * pHwRef)345 phHciNfc_SWP_Get_Status(
346 void *psHciHandle,
347 void *pHwRef
348 )
349 {
350 NFCSTATUS status = NFCSTATUS_SUCCESS;
351 /* static uint8_t param = 0 ; */
352 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
353
354 if((NULL == psHciContext)||(NULL == pHwRef))
355 {
356 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
357 }
358 else if(NULL == psHciContext->p_swp_info)
359 {
360 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
361 }
362 else
363 {
364 phHciNfc_SWP_Info_t *ps_swp_info=NULL;
365 phHciNfc_Pipe_Info_t *ps_pipe_info=NULL;
366
367 ps_swp_info = (phHciNfc_SWP_Info_t*)psHciContext->p_swp_info;
368 ps_pipe_info = ps_swp_info->p_pipe_info;
369
370 if(NULL == ps_pipe_info)
371 {
372 status = PHNFCSTVAL(CID_NFC_HCI,
373 NFCSTATUS_INVALID_HCI_INFORMATION);
374 }
375 else
376 {
377 ps_pipe_info->reg_index = NXP_SWP_STATUS_INDEX;
378 status = phHciNfc_Send_Generic_Cmd(psHciContext, pHwRef,
379 ps_swp_info->pipe_id,
380 (uint8_t)ANY_GET_PARAMETER);
381 }
382 }
383 return status;
384 }
385
386
387 NFCSTATUS
phHciNfc_SWP_Get_Bitrate(void * psHciHandle,void * pHwRef)388 phHciNfc_SWP_Get_Bitrate(
389 void *psHciHandle,
390 void *pHwRef
391 )
392 {
393 NFCSTATUS status = NFCSTATUS_SUCCESS;
394 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)
395 psHciHandle);
396
397 if((NULL == psHciContext) || (NULL == pHwRef))
398 {
399 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
400 }
401 else if(NULL == psHciContext->p_swp_info)
402 {
403 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
404 }
405 else
406 {
407 phHciNfc_SWP_Info_t *ps_swp_info = NULL;
408
409 ps_swp_info = (phHciNfc_SWP_Info_t*)psHciContext->p_swp_info;
410
411 status = phHciNfc_DevMgmt_Get_Info(psHciContext, pHwRef,
412 NFC_ADDRESS_SWP_BITRATE, &(ps_swp_info->uicc_bitrate));
413
414 }
415 return status;
416 }
417
418
419 NFCSTATUS
phHciNfc_SWP_Protection(void * psHciHandle,void * pHwRef,uint8_t mode)420 phHciNfc_SWP_Protection(
421 void *psHciHandle,
422 void *pHwRef,
423 uint8_t mode
424 )
425 {
426 NFCSTATUS status = NFCSTATUS_SUCCESS;
427 static uint8_t param = 0 ;
428 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)psHciHandle);
429
430 if((NULL == psHciContext)||(NULL == pHwRef))
431 {
432 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
433 }
434 else if(NULL == psHciContext->p_swp_info)
435 {
436 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
437 }
438 else
439 {
440 phHciNfc_SWP_Info_t *ps_swp_info=NULL;
441 phHciNfc_Pipe_Info_t *ps_pipe_info=NULL;
442
443 ps_swp_info = (phHciNfc_SWP_Info_t*)psHciContext->p_swp_info;
444 ps_pipe_info = ps_swp_info->p_pipe_info;
445
446 if(NULL == ps_pipe_info)
447 {
448 status = PHNFCSTVAL(CID_NFC_HCI,
449 NFCSTATUS_INVALID_HCI_INFORMATION);
450 }
451 else
452 {
453 ps_pipe_info->reg_index = NXP_SWP_PROTECTED_INDEX;
454 /* Enable/Disable SWP Protection */
455 param = (uint8_t)mode;
456 ps_pipe_info->param_info =(void*)¶m ;
457 ps_pipe_info->param_length = sizeof(param) ;
458 status = phHciNfc_Send_Generic_Cmd(psHciContext, pHwRef,
459 ps_swp_info->pipe_id,
460 (uint8_t)ANY_SET_PARAMETER);
461 }
462
463 }
464 return status;
465 }
466
467
468
469
470 static
471 NFCSTATUS
phHciNfc_SWP_InfoUpdate(phHciNfc_sContext_t * psHciContext,uint8_t index,uint8_t * reg_value,uint8_t reg_length)472 phHciNfc_SWP_InfoUpdate(
473 phHciNfc_sContext_t *psHciContext,
474 uint8_t index,
475 uint8_t *reg_value,
476 uint8_t reg_length
477 )
478 {
479 phHciNfc_SWP_Info_t *ps_swp_info=NULL;
480 NFCSTATUS status = NFCSTATUS_SUCCESS;
481
482 ps_swp_info = (phHciNfc_SWP_Info_t *)
483 psHciContext->p_swp_info ;
484
485 /* To remove "warning (VS C4100) : unreferenced formal parameter" */
486 PHNFC_UNUSED_VARIABLE(reg_length);
487 switch(index)
488 {
489 case NXP_SWP_DEFAULT_MODE_INDEX:
490 {
491 HCI_PRINT_BUFFER("\tUICC Enable Register:",reg_value,reg_length);
492 break;
493 }
494 /* Get the Status of the UICC Connection */
495 case NXP_SWP_STATUS_INDEX:
496 {
497 HCI_PRINT_BUFFER("\tUICC Connection Status:", reg_value, reg_length);
498 ps_swp_info->uicc_status = (phHciNfc_SWP_Status_t ) *reg_value ;
499 break;
500 }
501 case NXP_SWP_PROTECTED_INDEX:
502 {
503 HCI_PRINT_BUFFER("\t UICC Card Emulation Rights :",reg_value,reg_length);
504
505 break;
506 }
507 default:
508 {
509 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_INFORMATION);
510 break;
511 }
512 } /* End of switch(index) */
513
514 return status;
515 }
516
517 NFCSTATUS
phHciNfc_SWP_Configure_Mode(void * psHciHandle,void * pHwRef,uint8_t uicc_mode)518 phHciNfc_SWP_Configure_Mode(
519 void *psHciHandle,
520 void *pHwRef,
521 uint8_t uicc_mode
522 )
523 {
524 NFCSTATUS status = NFCSTATUS_SUCCESS;
525 static uint8_t param = 0;
526 phHciNfc_sContext_t *psHciContext = ((phHciNfc_sContext_t *)
527 psHciHandle);
528
529 if( (NULL == psHciContext)||(NULL == pHwRef))
530 {
531 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
532 }
533 else if ( NULL == psHciContext->p_swp_info )
534 {
535 status = PHNFCSTVAL(CID_NFC_HCI,
536 NFCSTATUS_INVALID_HCI_INFORMATION);
537 }
538 else
539 {
540 phHciNfc_SWP_Info_t *ps_swp_info=NULL;
541 phHciNfc_Pipe_Info_t *ps_pipe_info=NULL;
542
543 ps_swp_info = (phHciNfc_SWP_Info_t*)psHciContext->p_swp_info;
544
545 ps_pipe_info = ps_swp_info->p_pipe_info;
546 if(NULL == ps_pipe_info)
547 {
548 status = PHNFCSTVAL(CID_NFC_HCI,
549 NFCSTATUS_INVALID_HCI_INFORMATION);
550 }
551 else
552 {
553 /* Switch the Mode of the SmartMx */
554 param = uicc_mode;
555 ps_pipe_info->param_info =(void*)¶m ;
556 ps_pipe_info->param_length = sizeof(param) ;
557 status = phHciNfc_Send_SWP_Event( psHciContext, pHwRef,
558 ps_swp_info->pipe_id,
559 NXP_EVT_SWP_SWITCH_MODE );
560
561 /* Send the Success Status as this is an event */
562 status = ((status == NFCSTATUS_PENDING)?
563 NFCSTATUS_SUCCESS : status);
564
565 }/* End of else part*/
566 }
567 return status;
568 }
569
570 static
571 NFCSTATUS
phHciNfc_Recv_SWP_Event(void * psContext,void * pHwRef,uint8_t * pEvent,uint8_t length)572 phHciNfc_Recv_SWP_Event(
573 void *psContext,
574 void *pHwRef,
575 uint8_t *pEvent,
576 #ifdef ONE_BYTE_LEN
577 uint8_t length
578 #else
579 uint16_t length
580 #endif
581 )
582 {
583 NFCSTATUS status = NFCSTATUS_SUCCESS;
584 phHciNfc_sContext_t *psHciContext =
585 (phHciNfc_sContext_t *)psContext ;
586 static phHal_sEventInfo_t EventInfo;
587
588
589 if( (NULL == psHciContext) || (NULL == pHwRef) || (NULL == pEvent)
590 || (length == 0))
591 {
592 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
593 }
594 else if(NULL == psHciContext->p_swp_info)
595 {
596 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_FEATURE_NOT_SUPPORTED);
597 }
598 else
599 {
600 phHciNfc_SWP_Info_t *ps_swp_info=NULL;
601
602 ps_swp_info = (phHciNfc_SWP_Info_t *)
603 psHciContext->p_swp_info ;
604 if( NULL == ps_swp_info->p_pipe_info)
605 {
606 status = PHNFCSTVAL(CID_NFC_HCI,
607 NFCSTATUS_INVALID_HCI_INFORMATION);
608 }
609 else
610 {
611 phHciNfc_HCP_Packet_t *p_packet = NULL;
612 phHciNfc_HCP_Message_t *message = NULL;
613 uint8_t EventType = 0;
614
615 p_packet = (phHciNfc_HCP_Packet_t *)pEvent;
616 message = &(p_packet->msg.message);
617 /* Get the instruction bits from the Message Header */
618 EventType = (uint8_t) GET_BITS8( message->msg_header,
619 HCP_MSG_INSTRUCTION_OFFSET, HCP_MSG_INSTRUCTION_LEN);
620
621 EventInfo.eventHost = phHal_eHostController;
622 EventInfo.eventSource = phHal_ePICC_DevType;
623 /* Occurrence of the Protected events for reporting */
624 if (NXP_EVT_SWP_PROTECTED == EventType)
625 {
626 EventInfo.eventType = NFC_EVT_PROTECTED;
627 }
628 else
629 {
630 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_HCI_RESPONSE);
631 }
632
633 if (NFCSTATUS_SUCCESS == status )
634 {
635 phHciNfc_Notify_Event( psHciContext, pHwRef,
636 NFC_NOTIFY_EVENT, (void*)&EventInfo);
637 }
638
639 }
640 }
641 return status;
642 }
643
644
645
646 static
647 NFCSTATUS
phHciNfc_Send_SWP_Event(phHciNfc_sContext_t * psHciContext,void * pHwRef,uint8_t pipe_id,uint8_t event)648 phHciNfc_Send_SWP_Event(
649 phHciNfc_sContext_t *psHciContext,
650 void *pHwRef,
651 uint8_t pipe_id,
652 uint8_t event
653 )
654 {
655 phHciNfc_HCP_Packet_t *hcp_packet = NULL;
656 phHciNfc_HCP_Message_t *hcp_message = NULL;
657 phHciNfc_Pipe_Info_t *p_pipe_info = NULL;
658 uint8_t length = 0;
659 uint8_t i=0;
660 NFCSTATUS status = NFCSTATUS_SUCCESS;
661
662 p_pipe_info = (phHciNfc_Pipe_Info_t *)
663 psHciContext->p_pipe_list[pipe_id];
664 psHciContext->tx_total = 0 ;
665 length = (length + HCP_HEADER_LEN);
666
667 hcp_packet = (phHciNfc_HCP_Packet_t *) psHciContext->send_buffer;
668 /* Construct the HCP Frame */
669 phHciNfc_Build_HCPFrame(hcp_packet,HCP_CHAINBIT_DEFAULT,
670 (uint8_t) pipe_id,
671 HCP_MSG_TYPE_EVENT, event);
672
673 hcp_message = &(hcp_packet->msg.message);
674
675 phHciNfc_Append_HCPFrame((uint8_t *)hcp_message->payload,
676 i,
677 (uint8_t *)p_pipe_info->param_info,
678 p_pipe_info->param_length);
679 length = (uint8_t)(length + i + p_pipe_info->param_length);
680
681 p_pipe_info->sent_msg_type = HCP_MSG_TYPE_EVENT ;
682 p_pipe_info->prev_msg = event ;
683 psHciContext->tx_total = length;
684
685 /* Send the Constructed HCP packet to the lower layer */
686 status = phHciNfc_Send_HCP( psHciContext, pHwRef );
687 if(NFCSTATUS_PENDING == status)
688 {
689 ((phHciNfc_SWP_Info_t *)psHciContext->p_swp_info)->current_seq =
690 ((phHciNfc_SWP_Info_t *)psHciContext->p_swp_info)->next_seq;
691 p_pipe_info->prev_status = status;
692 }
693
694 return status;
695 }
696
697 NFCSTATUS
phHciNfc_SWP_Update_Sequence(phHciNfc_sContext_t * psHciContext,phHciNfc_eSeqType_t SWP_seq)698 phHciNfc_SWP_Update_Sequence(
699 phHciNfc_sContext_t *psHciContext,
700 phHciNfc_eSeqType_t SWP_seq
701 )
702 {
703 NFCSTATUS status = NFCSTATUS_SUCCESS;
704 phHciNfc_SWP_Info_t *ps_swp_info=NULL;
705 if( NULL == psHciContext )
706 {
707 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
708 }
709 else if( NULL == psHciContext->p_swp_info )
710 {
711 status = PHNFCSTVAL(CID_NFC_HCI,
712 NFCSTATUS_INVALID_HCI_INFORMATION);
713 }
714 else
715 {
716 ps_swp_info = (phHciNfc_SWP_Info_t *)
717 psHciContext->p_swp_info ;
718 switch(SWP_seq)
719 {
720 case RESET_SEQ:
721 case INIT_SEQ:
722 {
723 ps_swp_info->current_seq = SWP_INVALID_SEQUENCE;
724 ps_swp_info->next_seq = SWP_INVALID_SEQUENCE ;
725 break;
726 }
727 case UPDATE_SEQ:
728 {
729 ps_swp_info->current_seq = ps_swp_info->next_seq;
730 break;
731 }
732 case REL_SEQ:
733 {
734 ps_swp_info->current_seq = SWP_INVALID_SEQUENCE;
735 ps_swp_info->next_seq = SWP_INVALID_SEQUENCE;
736 break;
737 }
738 case CONFIG_SEQ:
739 {
740 ps_swp_info->current_seq = SWP_STATUS_SEQ;
741 ps_swp_info->next_seq = SWP_STATUS_SEQ;
742 break;
743 }
744 default:
745 {
746 break;
747 }
748 }
749 }
750 return status;
751 }
752
753 NFCSTATUS
phHciNfc_SWP_Config_Sequence(phHciNfc_sContext_t * psHciContext,void * pHwRef,phHal_sEmulationCfg_t * ps_emulation_cfg)754 phHciNfc_SWP_Config_Sequence(
755 phHciNfc_sContext_t *psHciContext,
756 void *pHwRef,
757 phHal_sEmulationCfg_t *ps_emulation_cfg
758 )
759 {
760 NFCSTATUS status = NFCSTATUS_SUCCESS;
761 phHciNfc_SWP_Info_t *ps_swp_info=NULL;
762
763 if ((NULL == psHciContext) || (NULL == pHwRef) ||
764 (NULL == ps_emulation_cfg))
765 {
766 status = PHNFCSTVAL(CID_NFC_HCI, NFCSTATUS_INVALID_PARAMETER);
767 }
768 else if( NULL == psHciContext->p_swp_info )
769 {
770 status = PHNFCSTVAL(CID_NFC_HCI,
771 NFCSTATUS_INVALID_HCI_INFORMATION);
772 }
773 else
774 {
775 phHciNfc_Pipe_Info_t *ps_pipe_info = NULL;
776 phHal_sUiccEmuCfg_t *uicc_config =
777 &(ps_emulation_cfg->config.uiccEmuCfg);
778
779 ps_swp_info = (phHciNfc_SWP_Info_t *)psHciContext->p_swp_info;
780 ps_pipe_info = ps_swp_info->p_pipe_info;
781
782 if (NULL == ps_pipe_info)
783 {
784 status = PHNFCSTVAL(CID_NFC_HCI,
785 NFCSTATUS_INVALID_HCI_INFORMATION);
786 }
787 else
788 {
789 switch(ps_swp_info->current_seq)
790 {
791 case SWP_STATUS_SEQ :
792 {
793 status = phHciNfc_SWP_Configure_Default( psHciContext,
794 pHwRef, uicc_config->enableUicc );
795
796 if(status == NFCSTATUS_PENDING)
797 {
798 ps_swp_info->next_seq = SWP_STATUS_SEQ;
799 status = NFCSTATUS_SUCCESS;
800 }
801 break;
802 }
803 case SWP_MODE_SEQ :
804 {
805 status = phHciNfc_SWP_Configure_Mode( psHciContext,
806 pHwRef, UICC_SWITCH_MODE_DEFAULT );
807 /* UICC_SWITCH_MODE_ON */
808 if(status == NFCSTATUS_PENDING)
809 {
810 ps_swp_info->next_seq = SWP_STATUS_SEQ;
811 status = NFCSTATUS_SUCCESS;
812 }
813 break;
814 }
815 default :
816 {
817 status = PHNFCSTVAL(CID_NFC_HCI,
818 NFCSTATUS_INVALID_HCI_INFORMATION);
819 break;
820 }
821 }
822 }
823 }
824 return status;
825 }
826
827
828
829