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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
