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 * \file phFriNfc_Llcp.c
19 * \brief NFC LLCP core
20 *
21 * Project: NFC-FRI
22 *
23 */
24
25 /*include files*/
26 #include <phNfcLlcpTypes.h>
27 #include <phOsalNfc_Timer.h>
28
29 #include <phFriNfc_Llcp.h>
30 #include <phFriNfc_LlcpUtils.h>
31
32 /**
33 * \internal
34 * \name States of the LLC state machine.
35 *
36 */
37 /*@{*/
38 #define PHFRINFC_LLCP_STATE_RESET_INIT 0 /**< \internal Initial state.*/
39 #define PHFRINFC_LLCP_STATE_CHECKED 1 /**< \internal The tag has been checked for LLCP compliance.*/
40 #define PHFRINFC_LLCP_STATE_ACTIVATION 2 /**< \internal The deactivation phase.*/
41 #define PHFRINFC_LLCP_STATE_PAX 3 /**< \internal Parameter exchange phase.*/
42 #define PHFRINFC_LLCP_STATE_OPERATION_RECV 4 /**< \internal Normal operation phase (ready to receive).*/
43 #define PHFRINFC_LLCP_STATE_OPERATION_SEND 5 /**< \internal Normal operation phase (ready to send).*/
44 #define PHFRINFC_LLCP_STATE_DEACTIVATION 6 /**< \internal The deactivation phase.*/
45 /*@}*/
46
47 /**
48 * \internal
49 * \name Masks used for VERSION parsing.
50 *
51 */
52 /*@{*/
53 #define PHFRINFC_LLCP_VERSION_MAJOR_MASK 0xF0 /**< \internal Mask to apply to get major version number.*/
54 #define PHFRINFC_LLCP_VERSION_MINOR_MASK 0x0F /**< \internal Mask to apply to get major version number.*/
55 /*@}*/
56
57 /**
58 * \internal
59 * \name Invalid values for parameters.
60 *
61 */
62 /*@{*/
63 #define PHFRINFC_LLCP_INVALID_VERSION 0x00 /**< \internal Invalid VERSION value.*/
64 /*@}*/
65
66 /**
67 * \internal
68 * \name Internal constants.
69 *
70 */
71 /*@{*/
72 #define PHFRINFC_LLCP_MAX_PARAM_TLV_LENGTH \
73 (( PHFRINFC_LLCP_TLV_LENGTH_HEADER + PHFRINFC_LLCP_TLV_LENGTH_VERSION ) + \
74 ( PHFRINFC_LLCP_TLV_LENGTH_HEADER + PHFRINFC_LLCP_TLV_LENGTH_MIUX ) + \
75 ( PHFRINFC_LLCP_TLV_LENGTH_HEADER + PHFRINFC_LLCP_TLV_LENGTH_WKS ) + \
76 ( PHFRINFC_LLCP_TLV_LENGTH_HEADER + PHFRINFC_LLCP_TLV_LENGTH_LTO ) + \
77 ( PHFRINFC_LLCP_TLV_LENGTH_HEADER + PHFRINFC_LLCP_TLV_LENGTH_OPT )) /**< \internal Maximum size of link params TLV.*/
78 /*@}*/
79
80
81
82 /* --------------------------- Internal functions ------------------------------ */
83
84 static void phFriNfc_Llcp_Receive_CB( void *pContext,
85 NFCSTATUS status,
86 phNfc_sData_t *psData);
87 static NFCSTATUS phFriNfc_Llcp_HandleIncomingPacket( phFriNfc_Llcp_t *Llcp,
88 phNfc_sData_t *psPacket );
89 static void phFriNfc_Llcp_ResetLTO( phFriNfc_Llcp_t *Llcp );
90 static NFCSTATUS phFriNfc_Llcp_InternalSend( phFriNfc_Llcp_t *Llcp,
91 phFriNfc_Llcp_sPacketHeader_t *psHeader,
92 phFriNfc_Llcp_sPacketSequence_t *psSequence,
93 phNfc_sData_t *psInfo );
94 static bool_t phFriNfc_Llcp_HandlePendingSend ( phFriNfc_Llcp_t *Llcp );
95
phFriNfc_Llcp_AllocateAndCopy(phNfc_sData_t * pOrig)96 static phNfc_sData_t * phFriNfc_Llcp_AllocateAndCopy(phNfc_sData_t * pOrig)
97 {
98 phNfc_sData_t * pDest = NULL;
99
100 if (pOrig == NULL)
101 {
102 return NULL;
103 }
104
105 pDest = phOsalNfc_GetMemory(sizeof(phNfc_sData_t));
106 if (pDest == NULL)
107 {
108 goto error;
109 }
110
111 pDest->buffer = phOsalNfc_GetMemory(pOrig->length);
112 if (pDest->buffer == NULL)
113 {
114 goto error;
115 }
116
117 memcpy(pDest->buffer, pOrig->buffer, pOrig->length);
118 pDest->length = pOrig->length;
119
120 return pDest;
121
122 error:
123 if (pDest != NULL)
124 {
125 if (pDest->buffer != NULL)
126 {
127 phOsalNfc_FreeMemory(pDest->buffer);
128 }
129 phOsalNfc_FreeMemory(pDest);
130 }
131 return NULL;
132 }
133
phFriNfc_Llcp_Deallocate(phNfc_sData_t * pData)134 static void phFriNfc_Llcp_Deallocate(phNfc_sData_t * pData)
135 {
136 if (pData != NULL)
137 {
138 if (pData->buffer != NULL)
139 {
140 phOsalNfc_FreeMemory(pData->buffer);
141 }
142 else
143 {
144 LLCP_PRINT("Warning, deallocating empty buffer");
145 }
146 phOsalNfc_FreeMemory(pData);
147 }
148 }
149
phFriNfc_Llcp_InternalDeactivate(phFriNfc_Llcp_t * Llcp)150 static NFCSTATUS phFriNfc_Llcp_InternalDeactivate( phFriNfc_Llcp_t *Llcp )
151 {
152 phFriNfc_Llcp_Send_CB_t pfSendCB;
153 void * pSendContext;
154 if ((Llcp->state == PHFRINFC_LLCP_STATE_OPERATION_RECV) ||
155 (Llcp->state == PHFRINFC_LLCP_STATE_OPERATION_SEND) ||
156 (Llcp->state == PHFRINFC_LLCP_STATE_PAX) ||
157 (Llcp->state == PHFRINFC_LLCP_STATE_ACTIVATION))
158 {
159 /* Update state */
160 Llcp->state = PHFRINFC_LLCP_STATE_DEACTIVATION;
161
162 /* Stop timer */
163 phOsalNfc_Timer_Stop(Llcp->hSymmTimer);
164
165 /* Return delayed send operation in error, in any */
166 if (Llcp->psSendInfo != NULL)
167 {
168 phFriNfc_Llcp_Deallocate(Llcp->psSendInfo);
169 Llcp->psSendInfo = NULL;
170 Llcp->psSendHeader = NULL;
171 Llcp->psSendSequence = NULL;
172 }
173 if (Llcp->pfSendCB != NULL)
174 {
175 /* Get Callback params */
176 pfSendCB = Llcp->pfSendCB;
177 pSendContext = Llcp->pSendContext;
178 /* Reset callback params */
179 Llcp->pfSendCB = NULL;
180 Llcp->pSendContext = NULL;
181 /* Call the callback */
182 (pfSendCB)(pSendContext, NFCSTATUS_FAILED);
183 }
184
185 /* Notify service layer */
186 Llcp->pfLink_CB(Llcp->pLinkContext, phFriNfc_LlcpMac_eLinkDeactivated);
187
188 /* Forward check request to MAC layer */
189 return phFriNfc_LlcpMac_Deactivate(&Llcp->MAC);
190 }
191
192 return NFCSTATUS_SUCCESS;
193 }
194
195
phFriNfc_Llcp_SendSymm(phFriNfc_Llcp_t * Llcp)196 static NFCSTATUS phFriNfc_Llcp_SendSymm( phFriNfc_Llcp_t *Llcp )
197 {
198 phFriNfc_Llcp_sPacketHeader_t sHeader;
199
200 sHeader.dsap = PHFRINFC_LLCP_SAP_LINK;
201 sHeader.ssap = PHFRINFC_LLCP_SAP_LINK;
202 sHeader.ptype = PHFRINFC_LLCP_PTYPE_SYMM;
203 return phFriNfc_Llcp_InternalSend(Llcp, &sHeader, NULL, NULL);
204 }
205
206
phFriNfc_Llcp_SendPax(phFriNfc_Llcp_t * Llcp,phFriNfc_Llcp_sLinkParameters_t * psLinkParams)207 static NFCSTATUS phFriNfc_Llcp_SendPax( phFriNfc_Llcp_t *Llcp, phFriNfc_Llcp_sLinkParameters_t *psLinkParams)
208 {
209 uint8_t pTLVBuffer[PHFRINFC_LLCP_MAX_PARAM_TLV_LENGTH];
210 phNfc_sData_t sParamsTLV;
211 phFriNfc_Llcp_sPacketHeader_t sHeader;
212 NFCSTATUS result;
213
214 /* Prepare link parameters TLV */
215 sParamsTLV.buffer = pTLVBuffer;
216 sParamsTLV.length = PHFRINFC_LLCP_MAX_PARAM_TLV_LENGTH;
217 result = phFriNfc_Llcp_EncodeLinkParams(&sParamsTLV, psLinkParams, PHFRINFC_LLCP_VERSION);
218 if (result != NFCSTATUS_SUCCESS)
219 {
220 /* Error while encoding */
221 return NFCSTATUS_FAILED;
222 }
223
224 /* Check if ready to send */
225 if (Llcp->state != PHFRINFC_LLCP_STATE_OPERATION_SEND)
226 {
227 /* No send pending, send the PAX packet */
228 sHeader.dsap = PHFRINFC_LLCP_SAP_LINK;
229 sHeader.ssap = PHFRINFC_LLCP_SAP_LINK;
230 sHeader.ptype = PHFRINFC_LLCP_PTYPE_PAX;
231 return phFriNfc_Llcp_InternalSend(Llcp, &sHeader, NULL, &sParamsTLV);
232 }
233 else
234 {
235 /* Error: A send is already pending, cannot send PAX */
236 /* NOTE: this should not happen since PAX are sent before any other packet ! */
237 return NFCSTATUS_FAILED;
238 }
239 }
240
241
phFriNfc_Llcp_SendDisconnect(phFriNfc_Llcp_t * Llcp)242 static NFCSTATUS phFriNfc_Llcp_SendDisconnect( phFriNfc_Llcp_t *Llcp )
243 {
244 phFriNfc_Llcp_sPacketHeader_t sHeader;
245
246 /* Check if ready to send */
247 if (Llcp->state != PHFRINFC_LLCP_STATE_OPERATION_SEND)
248 {
249 /* No send pending, send the DISC packet */
250 sHeader.dsap = PHFRINFC_LLCP_SAP_LINK;
251 sHeader.ssap = PHFRINFC_LLCP_SAP_LINK;
252 sHeader.ptype = PHFRINFC_LLCP_PTYPE_DISC;
253 return phFriNfc_Llcp_InternalSend(Llcp, &sHeader, NULL, NULL);
254 }
255 else
256 {
257 /* A send is already pending, raise a flag to send DISC as soon as possible */
258 Llcp->bDiscPendingFlag = TRUE;
259 return NFCSTATUS_PENDING;
260 }
261 }
262
263
phFriNfc_Llcp_Timer_CB(uint32_t TimerId,void * pContext)264 static void phFriNfc_Llcp_Timer_CB(uint32_t TimerId, void *pContext)
265 {
266 phFriNfc_Llcp_t *Llcp = (phFriNfc_Llcp_t*)pContext;
267
268 PHNFC_UNUSED_VARIABLE(TimerId);
269
270 /* Check current state */
271 if (Llcp->state == PHFRINFC_LLCP_STATE_OPERATION_RECV)
272 {
273 /* No data is coming before LTO, disconnecting */
274 phFriNfc_Llcp_InternalDeactivate(Llcp);
275 }
276 else if (Llcp->state == PHFRINFC_LLCP_STATE_OPERATION_SEND)
277 {
278 /* Send SYMM */
279 phFriNfc_Llcp_SendSymm(Llcp);
280 }
281 else
282 {
283 /* Nothing to do if not in Normal Operation state */
284 }
285 }
286
287
phFriNfc_Llcp_HandleAggregatedPacket(phFriNfc_Llcp_t * Llcp,phNfc_sData_t * psRawPacket)288 static NFCSTATUS phFriNfc_Llcp_HandleAggregatedPacket( phFriNfc_Llcp_t *Llcp,
289 phNfc_sData_t *psRawPacket )
290 {
291 phNfc_sData_t sInfo;
292 phNfc_sData_t sCurrentInfo;
293 uint16_t length;
294 NFCSTATUS status;
295
296 /* Get info field */
297 sInfo.buffer = psRawPacket->buffer + PHFRINFC_LLCP_PACKET_HEADER_SIZE;
298 sInfo.length = psRawPacket->length - PHFRINFC_LLCP_PACKET_HEADER_SIZE;
299
300 /* Check for empty info field */
301 if (sInfo.length == 0)
302 {
303 return NFCSTATUS_FAILED;
304 }
305
306 /* Check consistency */
307 while (sInfo.length != 0)
308 {
309 /* Check if enough room to read length */
310 if (sInfo.length < sizeof(sInfo.length))
311 {
312 return NFCSTATUS_FAILED;
313 }
314 /* Read length */
315 length = (sInfo.buffer[0] << 8) | sInfo.buffer[1];
316 /* Update info buffer */
317 sInfo.buffer += 2; /*Size of length field is 2*/
318 sInfo.length -= 2; /*Size of length field is 2*/
319 /* Check if declared length fits in remaining space */
320 if (length > sInfo.length)
321 {
322 return NFCSTATUS_FAILED;
323 }
324 /* Update info buffer */
325 sInfo.buffer += length;
326 sInfo.length -= length;
327 }
328
329 /* Get info field */
330 sInfo.buffer = psRawPacket->buffer + PHFRINFC_LLCP_PACKET_HEADER_SIZE;
331 sInfo.length = psRawPacket->length - PHFRINFC_LLCP_PACKET_HEADER_SIZE;
332
333 /* Handle aggregated packets */
334 while (sInfo.length != 0)
335 {
336 /* Read length */
337 length = (sInfo.buffer[0] << 8) | sInfo.buffer[1];
338 /* Update info buffer */
339 sInfo.buffer += 2; /* Size of length field is 2 */
340 sInfo.length -= 2; /*Size of length field is 2*/
341 /* Handle aggregated packet */
342 sCurrentInfo.buffer=sInfo.buffer;
343 sCurrentInfo.length=length;
344 status = phFriNfc_Llcp_HandleIncomingPacket(Llcp, &sCurrentInfo);
345 if ( (status != NFCSTATUS_SUCCESS) &&
346 (status != NFCSTATUS_PENDING) )
347 {
348 /* TODO: Error: invalid frame */
349 }
350 /* Update info buffer */
351 sInfo.buffer += length;
352 sInfo.length -= length;
353 }
354 return NFCSTATUS_SUCCESS;
355 }
356
357
phFriNfc_Llcp_ParseLinkParams(phNfc_sData_t * psParamsTLV,phFriNfc_Llcp_sLinkParameters_t * psParsedParams,uint8_t * pnParsedVersion)358 static NFCSTATUS phFriNfc_Llcp_ParseLinkParams( phNfc_sData_t *psParamsTLV,
359 phFriNfc_Llcp_sLinkParameters_t *psParsedParams,
360 uint8_t *pnParsedVersion )
361 {
362 NFCSTATUS status;
363 uint8_t type;
364 phFriNfc_Llcp_sLinkParameters_t sParams;
365 phNfc_sData_t sValueBuffer;
366 uint32_t offset = 0;
367 uint8_t version = PHFRINFC_LLCP_INVALID_VERSION;
368
369 /* Check for NULL pointers */
370 if ((psParamsTLV == NULL) || (psParsedParams == NULL) || (pnParsedVersion == NULL))
371 {
372 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_PARAMETER);
373 }
374
375 /* Prepare default param structure */
376 sParams.miu = PHFRINFC_LLCP_MIU_DEFAULT;
377 sParams.wks = PHFRINFC_LLCP_WKS_DEFAULT;
378 sParams.lto = PHFRINFC_LLCP_LTO_DEFAULT;
379 sParams.option = PHFRINFC_LLCP_OPTION_DEFAULT;
380
381 /* Decode TLV */
382 while (offset < psParamsTLV->length)
383 {
384 status = phFriNfc_Llcp_DecodeTLV(psParamsTLV, &offset, &type, &sValueBuffer);
385 if (status != NFCSTATUS_SUCCESS)
386 {
387 /* Error: Ill-formed TLV */
388 return status;
389 }
390 switch(type)
391 {
392 case PHFRINFC_LLCP_TLV_TYPE_VERSION:
393 {
394 /* Check length */
395 if (sValueBuffer.length != PHFRINFC_LLCP_TLV_LENGTH_VERSION)
396 {
397 /* Error : Ill-formed VERSION parameter TLV */
398 break;
399 }
400 /* Get VERSION */
401 version = sValueBuffer.buffer[0];
402 break;
403 }
404 case PHFRINFC_LLCP_TLV_TYPE_MIUX:
405 {
406 /* Check length */
407 if (sValueBuffer.length != PHFRINFC_LLCP_TLV_LENGTH_MIUX)
408 {
409 /* Error : Ill-formed MIUX parameter TLV */
410 break;
411 }
412 /* Get MIU */
413 sParams.miu = (PHFRINFC_LLCP_MIU_DEFAULT + ((sValueBuffer.buffer[0] << 8) | sValueBuffer.buffer[1])) & PHFRINFC_LLCP_TLV_MIUX_MASK;
414 break;
415 }
416 case PHFRINFC_LLCP_TLV_TYPE_WKS:
417 {
418 /* Check length */
419 if (sValueBuffer.length != PHFRINFC_LLCP_TLV_LENGTH_WKS)
420 {
421 /* Error : Ill-formed MIUX parameter TLV */
422 break;
423 }
424 /* Get WKS */
425 sParams.wks = (sValueBuffer.buffer[0] << 8) | sValueBuffer.buffer[1];
426 /* Ignored bits must always be set */
427 sParams.wks |= PHFRINFC_LLCP_TLV_WKS_MASK;
428 break;
429 }
430 case PHFRINFC_LLCP_TLV_TYPE_LTO:
431 {
432 /* Check length */
433 if (sValueBuffer.length != PHFRINFC_LLCP_TLV_LENGTH_LTO)
434 {
435 /* Error : Ill-formed LTO parameter TLV */
436 break;
437 }
438 /* Get LTO */
439 sParams.lto = sValueBuffer.buffer[0];
440 break;
441 }
442 case PHFRINFC_LLCP_TLV_TYPE_OPT:
443 {
444 /* Check length */
445 if (sValueBuffer.length != PHFRINFC_LLCP_TLV_LENGTH_OPT)
446 {
447 /* Error : Ill-formed OPT parameter TLV */
448 break;;
449 }
450 /* Get OPT */
451 sParams.option = sValueBuffer.buffer[0] & PHFRINFC_LLCP_TLV_OPT_MASK;
452 break;
453 }
454 default:
455 {
456 /* Error : Unknown Type */
457 break;
458 }
459 }
460 }
461
462 /* Check if a VERSION parameter has been provided */
463 if (version == PHFRINFC_LLCP_INVALID_VERSION)
464 {
465 /* Error : Mandatory VERSION parameter not provided */
466 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_PARAMETER);
467 }
468
469 /* Save response */
470 *pnParsedVersion = version;
471 memcpy(psParsedParams, &sParams, sizeof(phFriNfc_Llcp_sLinkParameters_t));
472
473 return NFCSTATUS_SUCCESS;
474 }
475
476
phFriNfc_Llcp_VersionAgreement(uint8_t localVersion,uint8_t remoteVersion,uint8_t * pNegociatedVersion)477 static NFCSTATUS phFriNfc_Llcp_VersionAgreement( uint8_t localVersion,
478 uint8_t remoteVersion,
479 uint8_t *pNegociatedVersion )
480 {
481 uint8_t localMajor = localVersion & PHFRINFC_LLCP_VERSION_MAJOR_MASK;
482 uint8_t localMinor = localVersion & PHFRINFC_LLCP_VERSION_MINOR_MASK;
483 uint8_t remoteMajor = remoteVersion & PHFRINFC_LLCP_VERSION_MAJOR_MASK;
484 uint8_t remoteMinor = remoteVersion & PHFRINFC_LLCP_VERSION_MINOR_MASK;
485 uint8_t negociatedVersion;
486
487 /* Check for NULL pointers */
488 if (pNegociatedVersion == NULL)
489 {
490 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_PARAMETER);
491 }
492
493 /* Compare Major numbers */
494 if (localMajor == remoteMajor)
495 {
496 /* Version agreement succeed : use lowest version */
497 negociatedVersion = localMajor | ((remoteMinor<localMinor)?remoteMinor:localMinor);
498 }
499 else if (localMajor > remoteMajor)
500 {
501 /* Decide if versions are compatible */
502 /* Currently, there is no backward compatibility to handle */
503 return NFCSTATUS_FAILED;
504 }
505 else /* if (localMajor < remoteMajor) */
506 {
507 /* It is up to the remote host to decide if versions are compatible */
508 /* Set negociated version to our local version, the remote will
509 deacivate the link if its own version agreement fails */
510 negociatedVersion = localVersion;
511 }
512
513 /* Save response */
514 *pNegociatedVersion = negociatedVersion;
515
516 return NFCSTATUS_SUCCESS;
517 }
518
519
phFriNfc_Llcp_InternalActivate(phFriNfc_Llcp_t * Llcp,phNfc_sData_t * psParamsTLV)520 static NFCSTATUS phFriNfc_Llcp_InternalActivate( phFriNfc_Llcp_t *Llcp,
521 phNfc_sData_t *psParamsTLV)
522 {
523 NFCSTATUS status;
524 phFriNfc_Llcp_sLinkParameters_t sRemoteParams;
525 uint8_t remoteVersion;
526 uint8_t negociatedVersion;
527 const uint16_t nMaxHeaderSize = PHFRINFC_LLCP_PACKET_HEADER_SIZE +
528 PHFRINFC_LLCP_PACKET_SEQUENCE_SIZE;
529
530 /* Parse parameters */
531 status = phFriNfc_Llcp_ParseLinkParams(psParamsTLV, &sRemoteParams, &remoteVersion);
532 if (status != NFCSTATUS_SUCCESS)
533 {
534 /* Error: invalid parameters TLV */
535 status = NFCSTATUS_FAILED;
536 }
537 else
538 {
539 /* Version agreement procedure */
540 status = phFriNfc_Llcp_VersionAgreement(PHFRINFC_LLCP_VERSION , remoteVersion, &negociatedVersion);
541 if (status != NFCSTATUS_SUCCESS)
542 {
543 /* Error: version agreement failed */
544 status = NFCSTATUS_FAILED;
545 }
546 else
547 {
548 /* Save parameters */
549 Llcp->version = negociatedVersion;
550 memcpy(&Llcp->sRemoteParams, &sRemoteParams, sizeof(phFriNfc_Llcp_sLinkParameters_t));
551
552 /* Update remote MIU to match local Tx buffer size */
553 if (Llcp->nTxBufferLength < (Llcp->sRemoteParams.miu + nMaxHeaderSize))
554 {
555 Llcp->sRemoteParams.miu = Llcp->nTxBufferLength - nMaxHeaderSize;
556 }
557
558 /* Initiate Symmetry procedure by resetting LTO timer */
559 /* NOTE: this also updates current state */
560 phFriNfc_Llcp_ResetLTO(Llcp);
561 }
562 }
563
564 /* Notify upper layer, if Activation failed CB called by Deactivate */
565 if (status == NFCSTATUS_SUCCESS)
566 {
567 /* Link activated ! */
568 Llcp->pfLink_CB(Llcp->pLinkContext, phFriNfc_LlcpMac_eLinkActivated);
569 }
570
571 return status;
572 }
573
574
phFriNfc_Llcp_HandleMACLinkActivated(phFriNfc_Llcp_t * Llcp,phNfc_sData_t * psParamsTLV)575 static NFCSTATUS phFriNfc_Llcp_HandleMACLinkActivated( phFriNfc_Llcp_t *Llcp,
576 phNfc_sData_t *psParamsTLV)
577 {
578 NFCSTATUS status = NFCSTATUS_SUCCESS;
579
580 /* Create the timer */
581 Llcp->hSymmTimer = phOsalNfc_Timer_Create();
582 if (Llcp->hSymmTimer == PH_OSALNFC_INVALID_TIMER_ID)
583 {
584 /* Error: unable to create timer */
585 return NFCSTATUS_INSUFFICIENT_RESOURCES;
586 }
587
588 /* Check if params received from MAC activation procedure */
589 if (psParamsTLV == NULL)
590 {
591 /* No params with selected MAC mapping, enter PAX mode for parameter exchange */
592 Llcp->state = PHFRINFC_LLCP_STATE_PAX;
593 /* Set default MIU for PAX exchange */
594 Llcp->sRemoteParams.miu = PHFRINFC_LLCP_MIU_DEFAULT;
595 /* If the local device is the initiator, it must initiate PAX exchange */
596 if (Llcp->eRole == phFriNfc_LlcpMac_ePeerTypeInitiator)
597 {
598 /* Send PAX */
599 status = phFriNfc_Llcp_SendPax(Llcp, &Llcp->sLocalParams);
600 }
601 }
602 else
603 {
604 /* Params exchanged during MAX activation, try LLC activation */
605 status = phFriNfc_Llcp_InternalActivate(Llcp, psParamsTLV);
606 }
607
608 if (status == NFCSTATUS_SUCCESS)
609 {
610 /* Start listening for incoming packets */
611 Llcp->sRxBuffer.length = Llcp->nRxBufferLength;
612 phFriNfc_LlcpMac_Receive(&Llcp->MAC, &Llcp->sRxBuffer, phFriNfc_Llcp_Receive_CB, Llcp);
613 }
614
615 return status;
616 }
617
618
phFriNfc_Llcp_HandleMACLinkDeactivated(phFriNfc_Llcp_t * Llcp)619 static void phFriNfc_Llcp_HandleMACLinkDeactivated( phFriNfc_Llcp_t *Llcp )
620 {
621 uint8_t state = Llcp->state;
622
623 /* Delete the timer */
624 if (Llcp->hSymmTimer != PH_OSALNFC_INVALID_TIMER_ID)
625 {
626 phOsalNfc_Timer_Delete(Llcp->hSymmTimer);
627 }
628
629 /* Reset state */
630 Llcp->state = PHFRINFC_LLCP_STATE_CHECKED;
631
632 switch (state)
633 {
634 case PHFRINFC_LLCP_STATE_DEACTIVATION:
635 {
636 /* The service layer has already been notified, nothing more to do */
637 break;
638 }
639 default:
640 {
641 /* Notify service layer of link failure */
642 Llcp->pfLink_CB(Llcp->pLinkContext, phFriNfc_LlcpMac_eLinkDeactivated);
643 break;
644 }
645 }
646 }
647
648
phFriNfc_Llcp_ChkLlcp_CB(void * pContext,NFCSTATUS status)649 static void phFriNfc_Llcp_ChkLlcp_CB( void *pContext,
650 NFCSTATUS status )
651 {
652 /* Get monitor from context */
653 phFriNfc_Llcp_t *Llcp = (phFriNfc_Llcp_t*)pContext;
654
655 /* Update state */
656 Llcp->state = PHFRINFC_LLCP_STATE_CHECKED;
657
658 /* Invoke callback */
659 Llcp->pfChk_CB(Llcp->pChkContext, status);
660 }
661
phFriNfc_Llcp_LinkStatus_CB(void * pContext,phFriNfc_LlcpMac_eLinkStatus_t eLinkStatus,phNfc_sData_t * psParamsTLV,phFriNfc_LlcpMac_ePeerType_t PeerRemoteDevType)662 static void phFriNfc_Llcp_LinkStatus_CB( void *pContext,
663 phFriNfc_LlcpMac_eLinkStatus_t eLinkStatus,
664 phNfc_sData_t *psParamsTLV,
665 phFriNfc_LlcpMac_ePeerType_t PeerRemoteDevType)
666 {
667 NFCSTATUS status;
668
669 /* Get monitor from context */
670 phFriNfc_Llcp_t *Llcp = (phFriNfc_Llcp_t*)pContext;
671
672 /* Save the local peer role (initiator/target) */
673 Llcp->eRole = PeerRemoteDevType;
674
675 /* Check new link status */
676 switch(eLinkStatus)
677 {
678 case phFriNfc_LlcpMac_eLinkActivated:
679 {
680 /* Handle MAC link activation */
681 status = phFriNfc_Llcp_HandleMACLinkActivated(Llcp, psParamsTLV);
682 if (status != NFCSTATUS_SUCCESS)
683 {
684 /* Error: LLC link activation procedure failed, deactivate MAC link */
685 status = phFriNfc_Llcp_InternalDeactivate(Llcp);
686 }
687 break;
688 }
689 case phFriNfc_LlcpMac_eLinkDeactivated:
690 {
691 /* Handle MAC link deactivation (cannot fail) */
692 phFriNfc_Llcp_HandleMACLinkDeactivated(Llcp);
693 break;
694 }
695 default:
696 {
697 /* Warning: Unknown link status, should not happen */
698 }
699 }
700 }
701
702
phFriNfc_Llcp_ResetLTO(phFriNfc_Llcp_t * Llcp)703 static void phFriNfc_Llcp_ResetLTO( phFriNfc_Llcp_t *Llcp )
704 {
705 uint32_t nDuration;
706
707 /* Stop timer */
708 phOsalNfc_Timer_Stop(Llcp->hSymmTimer);
709
710
711 /* Update state */
712 if (Llcp->state == PHFRINFC_LLCP_STATE_OPERATION_RECV)
713 {
714 Llcp->state = PHFRINFC_LLCP_STATE_OPERATION_SEND;
715 }
716 else if (Llcp->state == PHFRINFC_LLCP_STATE_OPERATION_SEND)
717 {
718 Llcp->state = PHFRINFC_LLCP_STATE_OPERATION_RECV;
719 }
720 else
721 {
722 /* Not yet in OPERATION state, perform first reset */
723 if (Llcp->eRole == phFriNfc_LlcpMac_ePeerTypeInitiator)
724 {
725 Llcp->state = PHFRINFC_LLCP_STATE_OPERATION_SEND;
726 }
727 else
728 {
729 Llcp->state = PHFRINFC_LLCP_STATE_OPERATION_RECV;
730 }
731 }
732
733 /* Calculate timer duration */
734 /* NOTE: nDuration is in 1/100s, and timer system takes values in 1/1000s */
735 if (Llcp->state == PHFRINFC_LLCP_STATE_OPERATION_RECV)
736 {
737 /* Response must be received before LTO announced by remote peer */
738 nDuration = Llcp->sRemoteParams.lto * 10;
739 }
740 else
741 {
742 /* Must answer before the local announced LTO */
743 /* NOTE: to ensure the answer is completely sent before LTO, the
744 timer is triggered _before_ LTO expiration */
745 /* TODO: make sure time scope is enough, and avoid use of magic number */
746 nDuration = (Llcp->sLocalParams.lto * 10) / 2;
747 }
748
749 LLCP_DEBUG("Starting LLCP timer with duration %d", nDuration);
750
751 /* Restart timer */
752 phOsalNfc_Timer_Start(
753 Llcp->hSymmTimer,
754 nDuration,
755 phFriNfc_Llcp_Timer_CB,
756 Llcp);
757 }
758
759
phFriNfc_Llcp_HandleLinkPacket(phFriNfc_Llcp_t * Llcp,phNfc_sData_t * psPacket)760 static NFCSTATUS phFriNfc_Llcp_HandleLinkPacket( phFriNfc_Llcp_t *Llcp,
761 phNfc_sData_t *psPacket )
762 {
763 NFCSTATUS result;
764 phFriNfc_Llcp_sPacketHeader_t sHeader;
765
766 /* Parse header */
767 phFriNfc_Llcp_Buffer2Header(psPacket->buffer, 0, &sHeader);
768
769 /* Check packet type */
770 switch (sHeader.ptype)
771 {
772 case PHFRINFC_LLCP_PTYPE_SYMM:
773 {
774 /* Nothing to do, the LTO is handled upon all packet reception */
775 result = NFCSTATUS_SUCCESS;
776 break;
777 }
778
779 case PHFRINFC_LLCP_PTYPE_AGF:
780 {
781 /* Handle the aggregated packet */
782 result = phFriNfc_Llcp_HandleAggregatedPacket(Llcp, psPacket);
783 if (result != NFCSTATUS_SUCCESS)
784 {
785 /* Error: invalid info field, dropping frame */
786 }
787 break;
788 }
789
790 case PHFRINFC_LLCP_PTYPE_DISC:
791 {
792 /* Handle link disconnection request */
793 result = phFriNfc_Llcp_InternalDeactivate(Llcp);
794 break;
795 }
796
797
798 case PHFRINFC_LLCP_PTYPE_FRMR:
799 {
800 /* TODO: what to do upon reception of FRMR on Link SAP ? */
801 result = NFCSTATUS_SUCCESS;
802 break;
803 }
804
805 case PHFRINFC_LLCP_PTYPE_PAX:
806 {
807 /* Ignore PAX when in Normal Operation */
808 result = NFCSTATUS_SUCCESS;
809 break;
810 }
811
812 default:
813 {
814 /* Error: invalid ptype field, dropping packet */
815 break;
816 }
817 }
818
819 return result;
820 }
821
822
phFriNfc_Llcp_HandleTransportPacket(phFriNfc_Llcp_t * Llcp,phNfc_sData_t * psPacket)823 static NFCSTATUS phFriNfc_Llcp_HandleTransportPacket( phFriNfc_Llcp_t *Llcp,
824 phNfc_sData_t *psPacket )
825 {
826 phFriNfc_Llcp_Recv_CB_t pfRecvCB;
827 void *pContext;
828 NFCSTATUS result = NFCSTATUS_SUCCESS;
829 phFriNfc_Llcp_sPacketHeader_t sHeader;
830
831 /* Forward to upper layer */
832 if (Llcp->pfRecvCB != NULL)
833 {
834 /* Get callback details */
835 pfRecvCB = Llcp->pfRecvCB;
836 pContext = Llcp->pRecvContext;
837 /* Reset callback details */
838 Llcp->pfRecvCB = NULL;
839 Llcp->pRecvContext = NULL;
840 /* Call the callback */
841 (pfRecvCB)(pContext, psPacket, NFCSTATUS_SUCCESS);
842 }
843
844 return result;
845 }
846
847
phFriNfc_Llcp_HandlePendingSend(phFriNfc_Llcp_t * Llcp)848 static bool_t phFriNfc_Llcp_HandlePendingSend ( phFriNfc_Llcp_t *Llcp )
849 {
850 phFriNfc_Llcp_sPacketHeader_t sHeader;
851 phNfc_sData_t sInfoBuffer;
852 phFriNfc_Llcp_sPacketHeader_t *psSendHeader = NULL;
853 phFriNfc_Llcp_sPacketSequence_t *psSendSequence = NULL;
854 phNfc_sData_t *psSendInfo = NULL;
855 NFCSTATUS result;
856 uint8_t bDeallocate = FALSE;
857 uint8_t return_value = FALSE;
858
859 /* Handle pending disconnection request */
860 if (Llcp->bDiscPendingFlag == TRUE)
861 {
862 /* Last send si acheived, send the pending DISC packet */
863 sHeader.dsap = PHFRINFC_LLCP_SAP_LINK;
864 sHeader.ssap = PHFRINFC_LLCP_SAP_LINK;
865 sHeader.ptype = PHFRINFC_LLCP_PTYPE_DISC;
866 /* Set send params */
867 psSendHeader = &sHeader;
868 /* Reset flag */
869 Llcp->bDiscPendingFlag = FALSE;
870 }
871 /* Handle pending frame reject request */
872 else if (Llcp->bFrmrPendingFlag == TRUE)
873 {
874 /* Last send si acheived, send the pending FRMR packet */
875 sInfoBuffer.buffer = Llcp->pFrmrInfo;
876 sInfoBuffer.length = sizeof(Llcp->pFrmrInfo);
877 /* Set send params */
878 psSendHeader = &Llcp->sFrmrHeader;
879 psSendInfo = &sInfoBuffer;
880 /* Reset flag */
881 Llcp->bFrmrPendingFlag = FALSE;
882 }
883 /* Handle pending service frame */
884 else if (Llcp->pfSendCB != NULL)
885 {
886 /* Set send params */
887 psSendHeader = Llcp->psSendHeader;
888 psSendSequence = Llcp->psSendSequence;
889 psSendInfo = Llcp->psSendInfo;
890 /* Reset pending send infos */
891 Llcp->psSendHeader = NULL;
892 Llcp->psSendSequence = NULL;
893 Llcp->psSendInfo = NULL;
894 bDeallocate = TRUE;
895 }
896
897 /* Perform send, if needed */
898 if (psSendHeader != NULL)
899 {
900 result = phFriNfc_Llcp_InternalSend(Llcp, psSendHeader, psSendSequence, psSendInfo);
901 if ((result != NFCSTATUS_SUCCESS) && (result != NFCSTATUS_PENDING))
902 {
903 /* Error: send failed, impossible to recover */
904 phFriNfc_Llcp_InternalDeactivate(Llcp);
905 }
906 return_value = TRUE;
907 } else if (Llcp->pfSendCB == NULL) {
908 // Nothing to send, send SYMM instead to allow peer to send something
909 // if it wants.
910 phFriNfc_Llcp_SendSymm(Llcp);
911 return_value = TRUE;
912 }
913
914 clean_and_return:
915 if (bDeallocate)
916 {
917 phFriNfc_Llcp_Deallocate(psSendInfo);
918 }
919
920 return return_value;
921 }
922
phFriNfc_Llcp_HandleIncomingPacket(phFriNfc_Llcp_t * Llcp,phNfc_sData_t * psPacket)923 static NFCSTATUS phFriNfc_Llcp_HandleIncomingPacket( phFriNfc_Llcp_t *Llcp,
924 phNfc_sData_t *psPacket )
925 {
926 NFCSTATUS status = NFCSTATUS_SUCCESS;
927 phFriNfc_Llcp_sPacketHeader_t sHeader;
928
929 /* Parse header */
930 phFriNfc_Llcp_Buffer2Header(psPacket->buffer, 0, &sHeader);
931
932 /* Check destination */
933 if (sHeader.dsap == PHFRINFC_LLCP_SAP_LINK)
934 {
935 /* Handle packet as destinated to the Link SAP */
936 status = phFriNfc_Llcp_HandleLinkPacket(Llcp, psPacket);
937 }
938 else if (sHeader.dsap >= PHFRINFC_LLCP_SAP_NUMBER)
939 {
940 /* NOTE: this cannot happen since "psHeader->dsap" is only 6-bit wide */
941 status = NFCSTATUS_FAILED;
942 }
943 else
944 {
945 /* Handle packet as destinated to the SDP and transport SAPs */
946 status = phFriNfc_Llcp_HandleTransportPacket(Llcp, psPacket);
947 }
948 return status;
949 }
950
951
phFriNfc_Llcp_Receive_CB(void * pContext,NFCSTATUS status,phNfc_sData_t * psData)952 static void phFriNfc_Llcp_Receive_CB( void *pContext,
953 NFCSTATUS status,
954 phNfc_sData_t *psData)
955 {
956 /* Get monitor from context */
957 phFriNfc_Llcp_t *Llcp = (phFriNfc_Llcp_t*)pContext;
958 NFCSTATUS result = NFCSTATUS_SUCCESS;
959 phFriNfc_Llcp_sPacketHeader_t sPacketHeader;
960
961 /* Check reception status and for pending disconnection */
962 if ((status != NFCSTATUS_SUCCESS) || (Llcp->bDiscPendingFlag == TRUE))
963 {
964 LLCP_DEBUG("\nReceived LLCP packet error - status = 0x%04x", status);
965 /* Reset disconnection operation */
966 Llcp->bDiscPendingFlag = FALSE;
967 /* Deactivate the link */
968 phFriNfc_Llcp_InternalDeactivate(Llcp);
969 return;
970 }
971
972 /* Parse header */
973 phFriNfc_Llcp_Buffer2Header(psData->buffer, 0, &sPacketHeader);
974
975 if (sPacketHeader.ptype != PHFRINFC_LLCP_PTYPE_SYMM)
976 {
977 LLCP_PRINT_BUFFER("\nReceived LLCP packet :", psData->buffer, psData->length);
978 }
979 else
980 {
981 LLCP_PRINT("?");
982 }
983
984
985 /* Check new link status */
986 switch(Llcp->state)
987 {
988 /* Handle packets in PAX-waiting state */
989 case PHFRINFC_LLCP_STATE_PAX:
990 {
991 /* Check packet type */
992 if (sPacketHeader.ptype == PHFRINFC_LLCP_PTYPE_PAX)
993 {
994 /* Params exchanged during MAC activation, try LLC activation */
995 result = phFriNfc_Llcp_InternalActivate(Llcp, psData+PHFRINFC_LLCP_PACKET_HEADER_SIZE);
996 /* If the local LLC is the target, it must answer the PAX */
997 if (Llcp->eRole == phFriNfc_LlcpMac_ePeerTypeTarget)
998 {
999 /* Send PAX */
1000 result = phFriNfc_Llcp_SendPax(Llcp, &Llcp->sLocalParams);
1001 }
1002 }
1003 else
1004 {
1005 /* Warning: Received packet with unhandled type in PAX-waiting state, drop it */
1006 }
1007 break;
1008 }
1009
1010 /* Handle normal operation packets */
1011 case PHFRINFC_LLCP_STATE_OPERATION_RECV:
1012 case PHFRINFC_LLCP_STATE_OPERATION_SEND:
1013 {
1014 /* Handle Symmetry procedure by resetting LTO timer */
1015 phFriNfc_Llcp_ResetLTO(Llcp);
1016 /* Handle packet */
1017 result = phFriNfc_Llcp_HandleIncomingPacket(Llcp, psData);
1018 if ( (result != NFCSTATUS_SUCCESS) &&
1019 (result != NFCSTATUS_PENDING) )
1020 {
1021 /* TODO: Error: invalid frame */
1022 }
1023 /* Perform pending send request, if any */
1024 phFriNfc_Llcp_HandlePendingSend(Llcp);
1025 break;
1026 }
1027
1028 default:
1029 {
1030 /* Warning: Should not receive packets in other states, drop them */
1031 }
1032 }
1033
1034 /* Restart reception */
1035 Llcp->sRxBuffer.length = Llcp->nRxBufferLength;
1036 phFriNfc_LlcpMac_Receive(&Llcp->MAC, &Llcp->sRxBuffer, phFriNfc_Llcp_Receive_CB, Llcp);
1037 }
1038
1039
phFriNfc_Llcp_Send_CB(void * pContext,NFCSTATUS status)1040 static void phFriNfc_Llcp_Send_CB( void *pContext,
1041 NFCSTATUS status )
1042 {
1043 /* Get monitor from context */
1044 phFriNfc_Llcp_t *Llcp = (phFriNfc_Llcp_t*)pContext;
1045 phFriNfc_Llcp_Send_CB_t pfSendCB;
1046 void *pSendContext;
1047
1048 /* Call the upper layer callback if last packet sent was */
1049 /* NOTE: if Llcp->psSendHeader is not NULL, this means that the send operation is still not initiated */
1050 if (Llcp->psSendHeader == NULL)
1051 {
1052 if (Llcp->pfSendCB != NULL)
1053 {
1054 /* Get Callback params */
1055 pfSendCB = Llcp->pfSendCB;
1056 pSendContext = Llcp->pSendContext;
1057 /* Reset callback params */
1058 Llcp->pfSendCB = NULL;
1059 Llcp->pSendContext = NULL;
1060 /* Call the callback */
1061 (pfSendCB)(pSendContext, status);
1062 }
1063 }
1064
1065 /* Check reception status */
1066 if (status != NFCSTATUS_SUCCESS)
1067 {
1068 /* Error: Reception failed, link must be down */
1069 phFriNfc_Llcp_InternalDeactivate(Llcp);
1070 }
1071 }
1072
1073
phFriNfc_Llcp_InternalSend(phFriNfc_Llcp_t * Llcp,phFriNfc_Llcp_sPacketHeader_t * psHeader,phFriNfc_Llcp_sPacketSequence_t * psSequence,phNfc_sData_t * psInfo)1074 static NFCSTATUS phFriNfc_Llcp_InternalSend( phFriNfc_Llcp_t *Llcp,
1075 phFriNfc_Llcp_sPacketHeader_t *psHeader,
1076 phFriNfc_Llcp_sPacketSequence_t *psSequence,
1077 phNfc_sData_t *psInfo )
1078 {
1079 NFCSTATUS status;
1080 phNfc_sData_t *psRawPacket = &Llcp->sTxBuffer; /* Use internal Tx buffer */
1081
1082 /* Handle Symmetry procedure */
1083 phFriNfc_Llcp_ResetLTO(Llcp);
1084
1085 /* Generate raw packet to send (aggregate header + sequence + info fields) */
1086 psRawPacket->length = 0;
1087 psRawPacket->length += phFriNfc_Llcp_Header2Buffer(psHeader, psRawPacket->buffer, psRawPacket->length);
1088 if (psSequence != NULL)
1089 {
1090 psRawPacket->length += phFriNfc_Llcp_Sequence2Buffer(psSequence, psRawPacket->buffer, psRawPacket->length);
1091 }
1092 if (psInfo != NULL)
1093 {
1094 memcpy(psRawPacket->buffer + psRawPacket->length, psInfo->buffer, psInfo->length);
1095 psRawPacket->length += psInfo->length;
1096 }
1097
1098 if (psHeader->ptype != PHFRINFC_LLCP_PTYPE_SYMM)
1099 {
1100 LLCP_PRINT_BUFFER("\nSending LLCP packet :", psRawPacket->buffer, psRawPacket->length);
1101 }
1102 else
1103 {
1104 LLCP_PRINT("!");
1105 }
1106
1107 /* Send raw packet */
1108 status = phFriNfc_LlcpMac_Send (
1109 &Llcp->MAC,
1110 psRawPacket,
1111 phFriNfc_Llcp_Send_CB,
1112 Llcp );
1113
1114 return status;
1115 }
1116
1117 /* ---------------------------- Public functions ------------------------------- */
1118
phFriNfc_Llcp_EncodeLinkParams(phNfc_sData_t * psRawBuffer,phFriNfc_Llcp_sLinkParameters_t * psLinkParams,uint8_t nVersion)1119 NFCSTATUS phFriNfc_Llcp_EncodeLinkParams( phNfc_sData_t *psRawBuffer,
1120 phFriNfc_Llcp_sLinkParameters_t *psLinkParams,
1121 uint8_t nVersion )
1122 {
1123 uint32_t nOffset = 0;
1124 uint16_t miux;
1125 uint16_t wks;
1126 uint8_t pValue[2];
1127 NFCSTATUS result = NFCSTATUS_SUCCESS;
1128
1129 /* Check parameters */
1130 if ((psRawBuffer == NULL) || (psLinkParams == NULL))
1131 {
1132 return NFCSTATUS_INVALID_PARAMETER;
1133 }
1134
1135 /* Encode mandatory VERSION field */
1136 if (result == NFCSTATUS_SUCCESS)
1137 {
1138 result = phFriNfc_Llcp_EncodeTLV(
1139 psRawBuffer,
1140 &nOffset,
1141 PHFRINFC_LLCP_TLV_TYPE_VERSION,
1142 PHFRINFC_LLCP_TLV_LENGTH_VERSION,
1143 &nVersion);
1144 }
1145
1146 /* Encode mandatory VERSION field */
1147 if (result == NFCSTATUS_SUCCESS)
1148 {
1149 /* Encode MIUX field, if needed */
1150 if (psLinkParams->miu != PHFRINFC_LLCP_MIU_DEFAULT)
1151 {
1152 miux = (psLinkParams->miu - PHFRINFC_LLCP_MIU_DEFAULT) & PHFRINFC_LLCP_TLV_MIUX_MASK;
1153 pValue[0] = (miux >> 8) & 0xFF;
1154 pValue[1] = miux & 0xFF;
1155 result = phFriNfc_Llcp_EncodeTLV(
1156 psRawBuffer,
1157 &nOffset,
1158 PHFRINFC_LLCP_TLV_TYPE_MIUX,
1159 PHFRINFC_LLCP_TLV_LENGTH_MIUX,
1160 pValue);
1161 }
1162 }
1163
1164 /* Encode WKS field */
1165 if (result == NFCSTATUS_SUCCESS)
1166 {
1167 wks = psLinkParams->wks | PHFRINFC_LLCP_TLV_WKS_MASK;
1168 pValue[0] = (wks >> 8) & 0xFF;
1169 pValue[1] = wks & 0xFF;
1170 result = phFriNfc_Llcp_EncodeTLV(
1171 psRawBuffer,
1172 &nOffset,
1173 PHFRINFC_LLCP_TLV_TYPE_WKS,
1174 PHFRINFC_LLCP_TLV_LENGTH_WKS,
1175 pValue);
1176 }
1177
1178 /* Encode LTO field, if needed */
1179 if (result == NFCSTATUS_SUCCESS)
1180 {
1181 if (psLinkParams->lto != PHFRINFC_LLCP_LTO_DEFAULT)
1182 {
1183 result = phFriNfc_Llcp_EncodeTLV(
1184 psRawBuffer,
1185 &nOffset,
1186 PHFRINFC_LLCP_TLV_TYPE_LTO,
1187 PHFRINFC_LLCP_TLV_LENGTH_LTO,
1188 &psLinkParams->lto);
1189 }
1190 }
1191
1192 /* Encode OPT field, if needed */
1193 if (result == NFCSTATUS_SUCCESS)
1194 {
1195 if (psLinkParams->option != PHFRINFC_LLCP_OPTION_DEFAULT)
1196 {
1197 result = phFriNfc_Llcp_EncodeTLV(
1198 psRawBuffer,
1199 &nOffset,
1200 PHFRINFC_LLCP_TLV_TYPE_OPT,
1201 PHFRINFC_LLCP_TLV_LENGTH_OPT,
1202 &psLinkParams->option);
1203 }
1204 }
1205
1206 if (result != NFCSTATUS_SUCCESS)
1207 {
1208 /* Error: failed to encode TLV */
1209 return NFCSTATUS_FAILED;
1210 }
1211
1212 /* Save new buffer size */
1213 psRawBuffer->length = nOffset;
1214
1215 return result;
1216 }
1217
1218
phFriNfc_Llcp_Reset(phFriNfc_Llcp_t * Llcp,void * LowerDevice,phFriNfc_Llcp_sLinkParameters_t * psLinkParams,void * pRxBuffer,uint16_t nRxBufferLength,void * pTxBuffer,uint16_t nTxBufferLength,phFriNfc_Llcp_LinkStatus_CB_t pfLink_CB,void * pContext)1219 NFCSTATUS phFriNfc_Llcp_Reset( phFriNfc_Llcp_t *Llcp,
1220 void *LowerDevice,
1221 phFriNfc_Llcp_sLinkParameters_t *psLinkParams,
1222 void *pRxBuffer,
1223 uint16_t nRxBufferLength,
1224 void *pTxBuffer,
1225 uint16_t nTxBufferLength,
1226 phFriNfc_Llcp_LinkStatus_CB_t pfLink_CB,
1227 void *pContext )
1228 {
1229 const uint16_t nMaxHeaderSize = PHFRINFC_LLCP_PACKET_HEADER_SIZE +
1230 PHFRINFC_LLCP_PACKET_SEQUENCE_SIZE;
1231 NFCSTATUS result;
1232
1233 /* Check parameters presence */
1234 if ((Llcp == NULL) || (LowerDevice == NULL) || (pfLink_CB == NULL) ||
1235 (pRxBuffer == NULL) || (pTxBuffer == NULL) )
1236 {
1237 return NFCSTATUS_INVALID_PARAMETER;
1238 }
1239
1240 /* Check parameters value */
1241 if (psLinkParams->miu < PHFRINFC_LLCP_MIU_DEFAULT)
1242 {
1243 return NFCSTATUS_INVALID_PARAMETER;
1244 }
1245
1246 /* Check if buffers are large enough to support minimal MIU */
1247 if ((nRxBufferLength < (nMaxHeaderSize + PHFRINFC_LLCP_MIU_DEFAULT)) ||
1248 (nTxBufferLength < (nMaxHeaderSize + PHFRINFC_LLCP_MIU_DEFAULT)) )
1249 {
1250 return NFCSTATUS_BUFFER_TOO_SMALL;
1251 }
1252
1253 /* Check compatibility between reception buffer size and announced MIU */
1254 if (nRxBufferLength < (nMaxHeaderSize + psLinkParams->miu))
1255 {
1256 return NFCSTATUS_BUFFER_TOO_SMALL;
1257 }
1258
1259 /* Start with a zero-filled monitor */
1260 memset(Llcp, 0x00, sizeof(phFriNfc_Llcp_t));
1261
1262 /* Reset the MAC Mapping layer */
1263 result = phFriNfc_LlcpMac_Reset(&Llcp->MAC, LowerDevice, phFriNfc_Llcp_LinkStatus_CB, Llcp);
1264 if (result != NFCSTATUS_SUCCESS) {
1265 return result;
1266 }
1267
1268 /* Save the working buffers */
1269 Llcp->sRxBuffer.buffer = pRxBuffer;
1270 Llcp->sRxBuffer.length = nRxBufferLength;
1271 Llcp->nRxBufferLength = nRxBufferLength;
1272 Llcp->sTxBuffer.buffer = pTxBuffer;
1273 Llcp->sTxBuffer.length = nTxBufferLength;
1274 Llcp->nTxBufferLength = nTxBufferLength;
1275
1276 /* Save the link status callback references */
1277 Llcp->pfLink_CB = pfLink_CB;
1278 Llcp->pLinkContext = pContext;
1279
1280 /* Save the local link parameters */
1281 memcpy(&Llcp->sLocalParams, psLinkParams, sizeof(phFriNfc_Llcp_sLinkParameters_t));
1282
1283 return NFCSTATUS_SUCCESS;
1284 }
1285
1286
phFriNfc_Llcp_ChkLlcp(phFriNfc_Llcp_t * Llcp,phHal_sRemoteDevInformation_t * psRemoteDevInfo,phFriNfc_Llcp_Check_CB_t pfCheck_CB,void * pContext)1287 NFCSTATUS phFriNfc_Llcp_ChkLlcp( phFriNfc_Llcp_t *Llcp,
1288 phHal_sRemoteDevInformation_t *psRemoteDevInfo,
1289 phFriNfc_Llcp_Check_CB_t pfCheck_CB,
1290 void *pContext )
1291 {
1292 /* Check parameters */
1293 if ( (Llcp == NULL) || (psRemoteDevInfo == NULL) || (pfCheck_CB == NULL) )
1294 {
1295 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_PARAMETER);
1296 }
1297
1298 /* Check current state */
1299 if( Llcp->state != PHFRINFC_LLCP_STATE_RESET_INIT ) {
1300 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_STATE);
1301 }
1302
1303 /* Save the compliance check callback */
1304 Llcp->pfChk_CB = pfCheck_CB;
1305 Llcp->pChkContext = pContext;
1306
1307 /* Forward check request to MAC layer */
1308 return phFriNfc_LlcpMac_ChkLlcp(&Llcp->MAC, psRemoteDevInfo, phFriNfc_Llcp_ChkLlcp_CB, (void*)Llcp);
1309 }
1310
1311
phFriNfc_Llcp_Activate(phFriNfc_Llcp_t * Llcp)1312 NFCSTATUS phFriNfc_Llcp_Activate( phFriNfc_Llcp_t *Llcp )
1313 {
1314 /* Check parameters */
1315 if (Llcp == NULL)
1316 {
1317 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_PARAMETER);
1318 }
1319
1320 /* Check current state */
1321 if( Llcp->state != PHFRINFC_LLCP_STATE_CHECKED ) {
1322 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_STATE);
1323 }
1324
1325 /* Update state */
1326 Llcp->state = PHFRINFC_LLCP_STATE_ACTIVATION;
1327
1328 /* Forward check request to MAC layer */
1329 return phFriNfc_LlcpMac_Activate(&Llcp->MAC);
1330 }
1331
1332
phFriNfc_Llcp_Deactivate(phFriNfc_Llcp_t * Llcp)1333 NFCSTATUS phFriNfc_Llcp_Deactivate( phFriNfc_Llcp_t *Llcp )
1334 {
1335 NFCSTATUS status;
1336
1337 /* Check parameters */
1338 if (Llcp == NULL)
1339 {
1340 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_PARAMETER);
1341 }
1342
1343 /* Check current state */
1344 if( (Llcp->state != PHFRINFC_LLCP_STATE_OPERATION_RECV) &&
1345 (Llcp->state != PHFRINFC_LLCP_STATE_OPERATION_SEND) ) {
1346 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_STATE);
1347 }
1348
1349 /* Send DISC packet */
1350 status = phFriNfc_Llcp_SendDisconnect(Llcp);
1351 if (status == NFCSTATUS_PENDING)
1352 {
1353 /* Wait for packet to be sent before deactivate link */
1354 return status;
1355 }
1356
1357 /* Perform actual deactivation */
1358 return phFriNfc_Llcp_InternalDeactivate(Llcp);
1359 }
1360
1361
phFriNfc_Llcp_GetLocalInfo(phFriNfc_Llcp_t * Llcp,phFriNfc_Llcp_sLinkParameters_t * pParams)1362 NFCSTATUS phFriNfc_Llcp_GetLocalInfo( phFriNfc_Llcp_t *Llcp,
1363 phFriNfc_Llcp_sLinkParameters_t *pParams )
1364 {
1365 /* Check parameters */
1366 if ((Llcp == NULL) || (pParams == NULL))
1367 {
1368 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_PARAMETER);
1369 }
1370
1371 /* Copy response */
1372 memcpy(pParams, &Llcp->sLocalParams, sizeof(phFriNfc_Llcp_sLinkParameters_t));
1373
1374 return NFCSTATUS_SUCCESS;
1375 }
1376
1377
phFriNfc_Llcp_GetRemoteInfo(phFriNfc_Llcp_t * Llcp,phFriNfc_Llcp_sLinkParameters_t * pParams)1378 NFCSTATUS phFriNfc_Llcp_GetRemoteInfo( phFriNfc_Llcp_t *Llcp,
1379 phFriNfc_Llcp_sLinkParameters_t *pParams )
1380 {
1381 /* Check parameters */
1382 if ((Llcp == NULL) || (pParams == NULL))
1383 {
1384 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_PARAMETER);
1385 }
1386
1387 /* Copy response */
1388 memcpy(pParams, &Llcp->sRemoteParams, sizeof(phFriNfc_Llcp_sLinkParameters_t));
1389
1390 return NFCSTATUS_SUCCESS;
1391 }
1392
1393
phFriNfc_Llcp_Send(phFriNfc_Llcp_t * Llcp,phFriNfc_Llcp_sPacketHeader_t * psHeader,phFriNfc_Llcp_sPacketSequence_t * psSequence,phNfc_sData_t * psInfo,phFriNfc_Llcp_Send_CB_t pfSend_CB,void * pContext)1394 NFCSTATUS phFriNfc_Llcp_Send( phFriNfc_Llcp_t *Llcp,
1395 phFriNfc_Llcp_sPacketHeader_t *psHeader,
1396 phFriNfc_Llcp_sPacketSequence_t *psSequence,
1397 phNfc_sData_t *psInfo,
1398 phFriNfc_Llcp_Send_CB_t pfSend_CB,
1399 void *pContext )
1400 {
1401 NFCSTATUS result;
1402
1403 /* Check parameters */
1404 if ((Llcp == NULL) || (psHeader == NULL) || (pfSend_CB == NULL))
1405 {
1406 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_PARAMETER);
1407 }
1408
1409 /* Check if previous phFriNfc_Llcp_Send() has finished */
1410 if (Llcp->pfSendCB != NULL)
1411 {
1412 /* Error: a send operation is already running */
1413 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_REJECTED);
1414 }
1415
1416 /* Save the callback parameters */
1417 Llcp->pfSendCB = pfSend_CB;
1418 Llcp->pSendContext = pContext;
1419
1420 if (Llcp->state == PHFRINFC_LLCP_STATE_OPERATION_SEND)
1421 {
1422 /* Ready to send */
1423 result = phFriNfc_Llcp_InternalSend(Llcp, psHeader, psSequence, psInfo);
1424 }
1425 else if (Llcp->state == PHFRINFC_LLCP_STATE_OPERATION_RECV)
1426 {
1427 /* Not ready to send, save send params for later use */
1428 Llcp->psSendHeader = psHeader;
1429 Llcp->psSendSequence = psSequence;
1430 Llcp->psSendInfo = phFriNfc_Llcp_AllocateAndCopy(psInfo);
1431 result = NFCSTATUS_PENDING;
1432 }
1433 else
1434 {
1435 /* Incorrect state for sending ! */
1436 result = PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_STATE);;
1437 }
1438
1439 if (result != NFCSTATUS_PENDING) {
1440 Llcp->pfSendCB = NULL;
1441 }
1442 return result;
1443 }
1444
1445
phFriNfc_Llcp_Recv(phFriNfc_Llcp_t * Llcp,phFriNfc_Llcp_Recv_CB_t pfRecv_CB,void * pContext)1446 NFCSTATUS phFriNfc_Llcp_Recv( phFriNfc_Llcp_t *Llcp,
1447 phFriNfc_Llcp_Recv_CB_t pfRecv_CB,
1448 void *pContext )
1449 {
1450 NFCSTATUS result = NFCSTATUS_SUCCESS;
1451
1452 /* Check parameters */
1453 if ((Llcp == NULL) || (pfRecv_CB == NULL))
1454 {
1455 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_INVALID_PARAMETER);
1456 }
1457
1458 /* Check if previous phFriNfc_Llcp_Recv() has finished */
1459 if (Llcp->pfRecvCB != NULL)
1460 {
1461 /* Error: a send operation is already running */
1462 return PHNFCSTVAL(CID_FRI_NFC_LLCP, NFCSTATUS_REJECTED);
1463 }
1464
1465 /* Save the callback parameters */
1466 Llcp->pfRecvCB = pfRecv_CB;
1467 Llcp->pRecvContext = pContext;
1468
1469 /* NOTE: nothing more to do, the receive function is called in background */
1470
1471 return result;
1472 }
1473