Google Git
Sign in
ara-mdk / platform / external / libnfc-nxp / 65e86fce1fe9e3f9aff98861c5e1e9d9ba6df9d5 / . / src / phLlcNfc_Frame.c
blob: af6176113a5fc590bb9d44c93586a4eebbf8c769 [file] [log] [blame]
/*
* Copyright (C) 2010 NXP Semiconductors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*!
* \file phLlcNfc_Frame.c
* \brief To append the I or S or U frames (LLC header).
*
* Project: NFC-FRI-1.1
*
* $Date: Tue Jun 1 14:41:26 2010 $
* $Author: ing02260 $
* $Revision: 1.88 $
* $Aliases: NFC_FRI1.1_WK1023_R35_1 $
*
*/
/*************************** Includes *******************************/
#include <phNfcTypes.h>
#include <phNfcStatus.h>
#include <phOsalNfc.h>
#include <phOsalNfc_Timer.h>
#include <phNfcInterface.h>
#include <phLlcNfc_DataTypes.h>
#include <phLlcNfc_Frame.h>
#include <phLlcNfc_Interface.h>
#include <phLlcNfc_Timer.h>
#ifdef ANDROID
#include <string.h>
#endif
/*********************** End of includes ****************************/
/***************************** Macros *******************************/
/************************ End of macros *****************************/
/***************************** Global variables *******************************/
#ifdef LLC_RELEASE_FLAG
extern uint8_t g_release_flag;
#endif /* #ifdef LLC_RELEASE_FLAG */
/************************ End of global variables *****************************/
/*********************** Local functions ****************************/
static
void
phLlcNfc_H_UpdateCrc(
uint8_t crcByte,
uint16_t *pCrc
);
/**
* \ingroup grp_hal_nfc_llc_helper
*
* \brief LLC helper functions <b>process the received U frame</b> function
*
* \copydoc page_reg This function is to process the U frame received from
* the device
*
* \param[in] psLlcCtxt Llc main structure information
* \param[in] llcPacket LLC packet information, inlcuding length information
*
* \retval NFCSTATUS_SUCCESS Operation successful.
* \retval NFCSTATUS_INVALID_PARAMETER At least one parameter of the function is invalid.
*
*/
static
NFCSTATUS
phLlcNfc_H_ProcessUFrame (
phLlcNfc_Context_t *psLlcCtxt
);
/**
* \ingroup grp_hal_nfc_llc_helper
*
* \brief LLC helper functions <b>process the received S frame</b> function
*
* \copydoc page_reg This function is to process the S frame received from
* the device
*
* \param[in] psLlcCtxt Llc main structure information
*
* \retval NFCSTATUS_SUCCESS Operation successful.
* \retval NFCSTATUS_INVALID_PARAMETER At least one parameter of the function is invalid.
*
*/
static
void
phLlcNfc_H_ProcessSFrame (
phLlcNfc_Context_t *psLlcCtxt
);
/**
* \ingroup grp_hal_nfc_llc_helper
*
* \brief LLC helper functions <b>Update I frame list</b> function
*
* \copydoc page_reg This function checks the nr value with the stored I frames
* and deletes the nodes which has been acknowledged.
*
* \param[in/out] psFrameInfo Frame structure information
* \param[in/out] psListInfo List information
*
* \retval number of deleted frames
*
*/
static
uint8_t
phLlcNfc_H_UpdateIFrameList(
phLlcNfc_Frame_t *psFrameInfo,
phLlcNfc_StoreIFrame_t *psListInfo
);
/**
* \ingroup grp_hal_nfc_llc_helper
*
* \brief LLC helper functions \b Delete list function
*
* \copydoc page_reg Delete the front node from the list
*
* \param[in] psFrameInfo Frame structure information
*
* \retval NFCSTATUS_SUCCESS Operation successful.
* \retval NFCSTATUS_INVALID_PARAMETER At least one parameter of the function is invalid.
*
*/
static
void
phLlcNfc_H_DeleteIFrame (
phLlcNfc_StoreIFrame_t *psList
);
/**
* \ingroup grp_hal_nfc_llc_helper
*
* \brief LLC helper functions <b>Get the LLC header</b> function
*
* \copydoc page_reg This function checks for the correctness fo the llc header
*
* \param[in] llcHeader The byte which gives the header information
*
* \retval phLlcNfc_eU_frame U frame type.
* \retval phLlcNfc_eI_frame I frame type.
* \retval phLlcNfc_eS_frame S frame type.
* \retval phLlcNfc_eErr_frame Error type
*
*/
static
phLlcNfc_FrameType_t
phLlcNfc_H_ChkGetLlcFrameType (
uint8_t llcHeader
);
/**
* \ingroup grp_hal_nfc_llc_helper
*
* \brief LLC helper functions \b Peek the data function
*
* \copydoc page_reg Get the packet information from the front node from the list
*
* \param[in] psListInfo The List information
* \param[in] packetinfo The packet information from the front node of the list
*
* \retval NFCSTATUS_SUCCESS Operation successful.
* \retval NFCSTATUS_INVALID_PARAMETER At least one parameter of the function is invalid.
*
*/
static
NFCSTATUS
phLlcNfc_H_IFrameList_Peek (
phLlcNfc_StoreIFrame_t *psList,
phLlcNfc_LlcPacket_t **psPacketinfo,
uint8_t position
);
/**
* \ingroup grp_hal_nfc_llc_helper
*
* \brief LLC helper functions <b>Update U frame information</b> function
*
* \copydoc page_reg This function updates the U frame information in the
* phLlcNfc_sFrame_t structure
*
* \param[in/out] psFrameInfo Frame information structure
* \param[in] llcPayload Llc payload information
*
* \retval NFCSTATUS_SUCCESS Operation successful.
* \retval NFCSTATUS_INVALID_PARAMETER At least one parameter of the function is invalid.
*
*/
static
NFCSTATUS
phLlcNfc_H_Update_ReceivedRSETInfo (
phLlcNfc_Frame_t *psFrameInfo,
phLlcNfc_Payload_t llcInfo
);
/**
* \ingroup grp_hal_nfc_llc_helper
*
* \brief LLC Reset frame information function
*
* \copydoc page_reg resets ns and nr value, when ack for U frame is received
*
* \param[in, out] psLlcCtxt Llc main structure information
*
* \retval NFCSTATUS_SUCCESS Operation successful.
* \retval NFCSTATUS_INVALID_PARAMETER At least one parameter of the function is invalid.
*
*/
static
void
phLlcNfc_H_ResetFrameInfo (
phLlcNfc_Context_t *psLlcCtxt
);
/**
* \ingroup grp_hal_nfc_llc_helper
*
* \brief LLC Reset frame sending function
*
* \copydoc page_reg Send URSET frame to PN544
*
* \param[in, out] psLlcCtxt Llc main structure information
*
* \retval NFCSTATUS_SUCCESS Operation successful.
* \retval NFCSTATUS_BUSY Write is pended, so wait till it completes.
* \retval NFCSTATUS_INVALID_PARAMETER At least one parameter of the function is invalid.
*
*/
NFCSTATUS
phLlcNfc_H_SendRSETFrame (
phLlcNfc_Context_t *psLlcCtxt
);
/**
* \ingroup grp_hal_nfc_llc_helper
*
* \brief LLC helper functions <b>process the received I frame</b> function
*
* \copydoc page_reg This function is to process the I frame received from
* the device
*
* \param[in] psLlcCtxt Llc main structure information
*
* \retval NFCSTATUS_SUCCESS Operation successful.
* \retval NFCSTATUS_INVALID_PARAMETER At least one parameter of the function is invalid.
*
*/
void
phLlcNfc_H_ProcessIFrame (
phLlcNfc_Context_t *psLlcCtxt
);
/******************** End of Local functions ************************/
/********************** Global variables ****************************/
/******************** End of Global Variables ***********************/
void phLlcNfc_H_Frame_Init (
phLlcNfc_Context_t *psLlcCtxt
)
{
if (NULL != psLlcCtxt)
{
/* Set all the other values to 0 */
(void)memset (&psLlcCtxt->s_frameinfo.s_llcpacket, 0,
sizeof(phLlcNfc_LlcPacket_t));
psLlcCtxt->s_frameinfo.window_size =
PH_LLCNFC_U_FRAME_MAX_WIN_SIZE;
/* Initialise the window size, N(S) and N(R) */
#ifdef PIGGY_BACK
psLlcCtxt->s_frameinfo.s_recv_store.winsize_cnt = 0;
#endif
psLlcCtxt->s_frameinfo.s_send_store.winsize_cnt = 0;
psLlcCtxt->s_frameinfo.n_s = 0;
psLlcCtxt->s_frameinfo.n_r = 0;
psLlcCtxt->s_frameinfo.rejected_ns = DEFAULT_PACKET_INPUT;
}
}
void
phLlcNfc_H_Frame_DeInit (
phLlcNfc_Frame_t *psFrameInfo
)
{
if (NULL != psFrameInfo)
{
/* Empty the frame information */
(void)memset(&psFrameInfo->s_llcpacket, 0,
sizeof(phLlcNfc_LlcPacket_t));
}
}
NFCSTATUS
phLlcNfc_H_CreateUFramePayload (
phLlcNfc_Context_t *psLlcCtxt,
phLlcNfc_LlcPacket_t *psLlcPacket,
uint8_t *pLlcPacketLength,
phLlcNfc_LlcCmd_t cmdType
)
{
/*
U frame packet (RSET)
Byte 0 = Length (4 to 6 bytes)
Byte 1 = Header
Byte 2 = window size (2 >= window size <= 4)
Byte 3 = capabilities (SREJ option enable/disable) (optional)
Byte 4 = Baud rate (optional)
Byte 5 = CRC1
Byte 6 = CRC2
*/
NFCSTATUS result = PHNFCSTVAL(CID_NFC_LLC,
NFCSTATUS_INVALID_PARAMETER);
phLlcNfc_Buffer_t *ps_llc_buf = NULL;
uint8_t index = 0;
if ((NULL != psLlcCtxt) && (NULL != psLlcPacket)
&& (NULL != pLlcPacketLength) &&
((phLlcNfc_e_rset == cmdType) || (phLlcNfc_e_ua == cmdType)))
{
result = NFCSTATUS_SUCCESS;
ps_llc_buf = &(psLlcPacket->s_llcbuf);
/* Get the header information */
ps_llc_buf->sllcpayload.llcheader =
(uint8_t)PH_LLCNFC_U_HEADER_INIT;
if (phLlcNfc_e_rset == cmdType)
{
/* RSET command */
ps_llc_buf->sllcpayload.llcheader =
(uint8_t)SET_BITS8(
ps_llc_buf->sllcpayload.llcheader,
PH_LLCNFC_U_FRAME_START_POS,
PH_LLCNFC_U_FRAME_NO_OF_POS,
(uint8_t)phLlcNfc_e_rset);
/* Default window size */
ps_llc_buf->sllcpayload.llcpayload[index] =
PH_LLCNFC_U_FRAME_MAX_WIN_SIZE;
index++;
/* Endpoint capabilities, SREJ not supported */
ps_llc_buf->sllcpayload.llcpayload[index] =
PH_LLCNFC_SREJ_BYTE_VALUE;
index++;
#ifdef ENABLE_BAUDRATE
/* baud rate 0x00 = 9600, 0x05 = 115200 */
ps_llc_buf->sllcpayload.llcpayload[index] =
(uint8_t)phLlcNfc_e_115200;
index++;
#endif /* #ifdef ENABLE_BAUDRATE */
}
else
{
/* UA frame */
ps_llc_buf->sllcpayload.llcheader = (uint8_t)
SET_BITS8(ps_llc_buf->sllcpayload.llcheader,
PH_LLCNFC_U_FRAME_START_POS,
PH_LLCNFC_U_FRAME_NO_OF_POS,
(uint8_t)phLlcNfc_e_ua);
}
/* LLC length byte updated (index + 2 CRC bytes +
1 byte of header) */
ps_llc_buf->llc_length_byte = (index +
PH_LLCNFC_NUM_OF_CRC_BYTES + 1);
/* Total LLC buffer size */
*pLlcPacketLength = psLlcPacket->llcbuf_len =
(ps_llc_buf->llc_length_byte + 1);
/*
psLlcPacket->s_llcbuf :
consists llc length byte + llc header + data + CRC
(which needs to be calculated by the below function)
psLlcPacket->llcbuf_len :
Total length of the above buffer
psLlcPacket->llcbuf_len - 2 :
-2 because the CRC has to be calculated, only for the
bytes which has llc length byte + llc header + data.
But total length (llcbuf_len) consists of above mentioned
things with 2 byte CRC
psLlcPacket->s_llcbuf.sllcpayload.llcpayload :
consists only data (no length byte and no llc header)
(psLlcPacket->llcbuf_len - 4) :
is the array index of the first CRC byte to be calculated
(psLlcPacket->llcbuf_len - 3) :
is the array index of the second CRC byte to be calculated
*/
index = psLlcPacket->llcbuf_len;
phLlcNfc_H_ComputeCrc((uint8_t *)ps_llc_buf,
(psLlcPacket->llcbuf_len - 2),
&(ps_llc_buf->sllcpayload.llcpayload[(index - 4)]),
&(ps_llc_buf->sllcpayload.llcpayload[(index - 3)]));
}
return result;
}
NFCSTATUS
phLlcNfc_H_CreateSFramePayload (
phLlcNfc_Frame_t *psFrameInfo,
phLlcNfc_LlcPacket_t *psLlcPacket,
phLlcNfc_LlcCmd_t cmdType
)
{
/*
S frame packet (RR or RNR or REJ or SREJ). Total bytes = 4
Byte 0 = Length (Length = 3 always for S frame)
Byte 1 = Header
Byte 2 = CRC1
Byte 3 = CRC2
*/
NFCSTATUS result = NFCSTATUS_SUCCESS;
phLlcNfc_Buffer_t *ps_llc_buf = NULL;
uint8_t length = 0;
ps_llc_buf = &(psLlcPacket->s_llcbuf);
/* Initial S frame header */
ps_llc_buf->sllcpayload.llcheader = PH_LLCNFC_S_HEADER_INIT;
/* Update the N(R) value */
ps_llc_buf->sllcpayload.llcheader = (uint8_t)SET_BITS8(
ps_llc_buf->sllcpayload.llcheader,
PH_LLCNFC_NR_START_BIT_POS,
PH_LLCNFC_NR_NS_NO_OF_BITS,
psFrameInfo->n_r);
/* Update the type bits of S frame */
ps_llc_buf->sllcpayload.llcheader = (uint8_t)
(ps_llc_buf->sllcpayload.llcheader | (uint8_t)cmdType);
/* Maximum S frame length */
psLlcPacket->llcbuf_len = (uint8_t)PH_LLCNFC_MAX_S_FRAME_LEN;
/* S frame length byte value */
ps_llc_buf->llc_length_byte = (uint8_t)
(psLlcPacket->llcbuf_len - 1);
/*
psFrameInfo->s_llcpacket.s_llcbuf :
consists llc length byte + llc header + data + CRC
(which needs to be calculated by the below function)
psFrameInfo->s_llcpacket.llcbuf_len :
Total length of the above buffer
psFrameInfo->s_llcpacket.llcbuf_len - 2 :
-2 because the CRC has to be calculated, only for the
bytes which has llc length byte + llc header + data.
But total length (llcbuf_len) consists of above mentioned
things with 2 byte CRC
psFrameInfo->s_llcpacket.s_llcbuf.sllcpayload.llcpayload :
consists only data (no length byte and no llc header)
psFrameInfo->s_llcpacket.s_llcbuf.sllcpayload.llcpayload :
contains only data sent by user.
(psFrameInfo->s_llcpacket.llcbuf_len - 4) :
is the array index of the first CRC byte to be calculated
(psFrameInfo->s_llcpacket.llcbuf_len - 3) :
is the array index of the second CRC byte to be calculated
*/
length = psLlcPacket->llcbuf_len;
phLlcNfc_H_ComputeCrc(
(uint8_t *)ps_llc_buf, (length - 2),
&(ps_llc_buf->sllcpayload.llcpayload[(length - 4)]),
&(ps_llc_buf->sllcpayload.llcpayload[(length - 3)]));
return result;
}
NFCSTATUS
phLlcNfc_H_CreateIFramePayload (
phLlcNfc_Frame_t *psFrameInfo,
phLlcNfc_LlcPacket_t *psLlcPacket,
uint8_t *pLlcBuf,
uint8_t llcBufLength
)
{
NFCSTATUS result = PHNFCSTVAL(CID_NFC_LLC,
NFCSTATUS_INVALID_PARAMETER);
phLlcNfc_Buffer_t *ps_llc_buf = NULL;
if ((NULL != psFrameInfo) && (NULL != psLlcPacket) &&
(NULL != pLlcBuf) && (llcBufLength > 0))
{
result = NFCSTATUS_SUCCESS;
ps_llc_buf = &(psLlcPacket->s_llcbuf);
(void)memcpy(&(ps_llc_buf->sllcpayload.llcpayload[0]),
pLlcBuf, llcBufLength);
psLlcPacket->llcbuf_len = (uint8_t)llcBufLength;
/* I frame header byte */
ps_llc_buf->sllcpayload.llcheader = PH_LLCNFC_I_HEADER_INIT;
/* Set the N(S) value */
ps_llc_buf->sllcpayload.llcheader = (uint8_t)
SET_BITS8(
ps_llc_buf->sllcpayload.llcheader,
PH_LLCNFC_NS_START_BIT_POS,
PH_LLCNFC_NR_NS_NO_OF_BITS,
psFrameInfo->n_s);
/* Set the N(R) value */
ps_llc_buf->sllcpayload.llcheader = (uint8_t)
SET_BITS8(
ps_llc_buf->sllcpayload.llcheader,
PH_LLCNFC_NR_START_BIT_POS,
PH_LLCNFC_NR_NS_NO_OF_BITS,
psFrameInfo->n_r);
/* Update the length byte, llc length byte value includes
data + CRC bytes + llc length byte */
ps_llc_buf->llc_length_byte =
(psLlcPacket->llcbuf_len +
PH_LLCNFC_NUM_OF_CRC_BYTES + 1);
/* Update total length, Total length is always equal to
llc length byte + 1 */
psLlcPacket->llcbuf_len =
(ps_llc_buf->llc_length_byte + 1);
/*
psFrameInfo->s_llcpacket.s_llcbuf :
consists llc length byte + llc header + data + CRC (which
needs to be calculated by the below function)
psFrameInfo->s_llcpacket.llcbuf_len :
Total length of the above buffer
psFrameInfo->s_llcpacket.llcbuf_len - 2 :
-2 because the CRC has to be calculated, only for the
bytes which has llc length byte + llc header + data.
But total length (llcbuf_len) consists of above mentioned
things with 2 byte CRC
psFrameInfo->s_llcpacket.s_llcbuf.sllcpayload.llcpayload :
contains only data sent by user.
(psFrameInfo->s_llcpacket.llcbuf_len - 4) :
is the array index of the first CRC byte to be calculated
(psFrameInfo->s_llcpacket.llcbuf_len - 3) :
is the array index of the second CRC byte to be calculated
*/
phLlcNfc_H_ComputeCrc(
(uint8_t*)ps_llc_buf,
(psLlcPacket->llcbuf_len - 2),
&(ps_llc_buf->sllcpayload.llcpayload
[(psLlcPacket->llcbuf_len - 4)]),
&(ps_llc_buf->sllcpayload.llcpayload
[(psLlcPacket->llcbuf_len - 3)]));
}
return result;
}
static
phLlcNfc_FrameType_t
phLlcNfc_H_ChkGetLlcFrameType (
uint8_t llcHeader
)
{
phLlcNfc_FrameType_t frame_type = phLlcNfc_eErr_frame;
/* Mask the header byte to know the actual frame types */
switch((llcHeader & PH_LLCNFC_LLC_HEADER_MASK))
{
case PH_LLCNFC_U_HEADER_INIT:
{
frame_type = phLlcNfc_eU_frame;
break;
}
case PH_LLCNFC_S_HEADER_INIT:
{
frame_type = phLlcNfc_eS_frame;
break;
}
default:
{
if (PH_LLCNFC_I_HEADER_INIT ==
(PH_LLCNFC_I_FRM_HEADER_MASK & llcHeader))
{
frame_type = phLlcNfc_eI_frame;
}
else
{
frame_type = phLlcNfc_eErr_frame;
}
break;
}
}
return frame_type;
}
static
NFCSTATUS
phLlcNfc_H_Update_ReceivedRSETInfo (
phLlcNfc_Frame_t *psFrameInfo,
phLlcNfc_Payload_t llcInfo
)
{
NFCSTATUS result = PHNFCSTVAL(CID_NFC_LLC, NFCSTATUS_INVALID_FORMAT);
uint8_t payload_index = 0;
if ((llcInfo.llcpayload[payload_index] >= PH_LLCNFC_U_FRAME_MIN_WIN_SIZE) &&
(llcInfo.llcpayload[payload_index] <= PH_LLCNFC_U_FRAME_MAX_WIN_SIZE))
{
result = NFCSTATUS_SUCCESS;
/* From the received buffer, get the window size from the
3rd byte (recvUBufLen[3]) of the buffer */
psFrameInfo->window_size = llcInfo.llcpayload[payload_index];
payload_index = (uint8_t)(payload_index + 1);
/* If 4th byte of the receive buffer (pRecvUBuf[4]) is
0x01 then SREJ can come from the device*/
psFrameInfo->srej_on_off = ((PH_LLCNFC_SREJ_BYTE_VALUE ==
llcInfo.llcpayload[payload_index])?
PH_LLCNFC_SREJ_BYTE_VALUE:0);
/* For present implementation, this should be always false
later stage remove if statement to work */
if (PH_LLCNFC_SREJ_BYTE_VALUE != psFrameInfo->srej_on_off)
{
result = PHNFCSTVAL(CID_NFC_LLC, NFCSTATUS_INVALID_FORMAT);
}
else
{
payload_index = (uint8_t)(payload_index + 1);
if (llcInfo.llcpayload[payload_index] >
(uint8_t)phLlcNfc_e_1228000)
{
/* Error byte */
result = PHNFCSTVAL(CID_NFC_LLC, NFCSTATUS_INVALID_FORMAT);
}
else
{
/* Get the baud rate from the 5th byte of the receive buffer */
psFrameInfo->baud_rate = (phLlcNfc_LlcBaudRate_t)
(llcInfo.llcpayload[payload_index]);
}
}
}
return result;
}
static
uint8_t
phLlcNfc_H_UpdateIFrameList(
phLlcNfc_Frame_t *psFrameInfo,
phLlcNfc_StoreIFrame_t *psListInfo
)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phLlcNfc_LlcPacket_t *pspktInfo = NULL;
uint8_t while_exit = FALSE;
uint8_t nr = 0;
uint8_t ns = 0;
uint8_t no_of_del_frames = 0;
PHNFC_UNUSED_VARIABLE(result);
if(0 == psListInfo->winsize_cnt)
{
while_exit = TRUE;
}
while (FALSE == while_exit)
{
/* Get the first node from the list */
result = phLlcNfc_H_IFrameList_Peek (psListInfo, &pspktInfo,
DEFAULT_PACKET_INPUT);
if (NULL != pspktInfo)
{
/* Get the N(R) value of the received packet and N(S) value of the
sent stored i frame */
ns = (uint8_t)GET_BITS8 (
pspktInfo->s_llcbuf.sllcpayload.llcheader,
PH_LLCNFC_NS_START_BIT_POS,
PH_LLCNFC_NR_NS_NO_OF_BITS);
nr = (uint8_t)GET_BITS8(
psFrameInfo->s_recvpacket.s_llcbuf.sllcpayload.llcheader,
PH_LLCNFC_NR_START_BIT_POS,
PH_LLCNFC_NR_NS_NO_OF_BITS);
/* Check the value of each i frame N(S) and
received ACKs N(R) */
#if 0
if(((ns <= nr) && ((nr - ns) <= psFrameInfo->window_size))
|| ((ns > nr) && (((PH_LLCNFC_MOD_NS_NR + nr) - ns) <=
PH_LLCNFC_U_FRAME_MAX_WIN_SIZE)))
#endif
if(((ns < nr) && ((nr - ns) <= psFrameInfo->window_size))
|| ((ns > nr) && (((PH_LLCNFC_MOD_NS_NR + nr) - ns) <=
PH_LLCNFC_U_FRAME_MAX_WIN_SIZE)))
{
phLlcNfc_H_DeleteIFrame (psListInfo);
no_of_del_frames = (uint8_t)(no_of_del_frames + 1);
}
else
{
while_exit = TRUE;
}
if(0 == psListInfo->winsize_cnt)
{
while_exit = TRUE;
}
}
else
{
while_exit = TRUE;
}
}
return no_of_del_frames;
}
NFCSTATUS
phLlcNfc_H_SendUserIFrame (
phLlcNfc_Context_t *psLlcCtxt,
phLlcNfc_StoreIFrame_t *psListInfo
)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phLlcNfc_Frame_t *ps_frame_info = NULL;
phLlcNfc_LlcPacket_t s_create_packet;
phLlcNfc_LlcPacket_t *ps_get_packet = NULL;
phLlcNfc_Payload_t *ps_llc_payload = NULL;
phLlcNfc_StoreIFrame_t *ps_store_frame = NULL;
uint8_t llc_header = 0,
length = 0;
if ((NULL == psLlcCtxt) || (NULL == psListInfo))
{
result = PHNFCSTVAL (CID_NFC_LLC, NFCSTATUS_INVALID_PARAMETER);
}
else if (0 == psListInfo->winsize_cnt)
{
result = PHNFCSTVAL (CID_NFC_LLC, NFCSTATUS_NOT_ALLOWED);
}
else
{
ps_frame_info = &(psLlcCtxt->s_frameinfo);
ps_store_frame = &(ps_frame_info->s_send_store);
if (
(ps_frame_info->n_s != ((ps_store_frame->winsize_cnt +
ps_store_frame->start_pos) % PH_LLCNFC_MOD_NS_NR))
)
{
/* Get the stored I frame, only if the new frame is sent
from the upper layer */
result = phLlcNfc_H_IFrameList_Peek (psListInfo, &ps_get_packet,
ps_frame_info->n_s);
}
if (NULL != ps_get_packet)
{
llc_header = ps_get_packet->s_llcbuf.sllcpayload.llcheader;
/* Update n(r) value for the header */
llc_header = (uint8_t)(llc_header | ps_frame_info->n_r);
/* Create the packet */
(void)memcpy ((void *)&(s_create_packet), (void *)ps_get_packet,
sizeof (phLlcNfc_LlcPacket_t));
s_create_packet.s_llcbuf.sllcpayload.llcheader = llc_header;
ps_llc_payload = &(s_create_packet.s_llcbuf.sllcpayload);
/* Length of the complete llc buffer, sent to PN544 */
length = s_create_packet.llcbuf_len;
/* Compute CRC for the created packet */
phLlcNfc_H_ComputeCrc ((uint8_t *)&(s_create_packet.s_llcbuf),
(length - 2),
(uint8_t *)&(ps_llc_payload->llcpayload[(length - 4)]),
(uint8_t *)&(ps_llc_payload->llcpayload[(length - 3)]));
/* Send the i frame */
result = phLlcNfc_Interface_Write (psLlcCtxt,
(uint8_t *)&(s_create_packet.s_llcbuf),
(uint32_t)s_create_packet.llcbuf_len);
ps_frame_info->write_status = result;
if (NFCSTATUS_BUSY == PHNFCSTATUS (result))
{
/* The below check is added because, write is already pended by some other
operation, so it has to complete, when it completes, then immediately
next write shall be called using the below updated variable
The below variable is checked for the resend or rejected i frame
because if due to timer or reject frame from PN544, an I frame
has been sent (means write has been pended then the variable shall
not be overwritten.
*/
ps_frame_info->write_wait_call = (phLlcNfc_eSentFrameType_t)
(((resend_i_frame == ps_frame_info->write_wait_call) ||
(rejected_i_frame == ps_frame_info->write_wait_call)) ?
ps_frame_info->write_wait_call : user_i_frame);
}
else
{
if (NFCSTATUS_PENDING == result)
{
/* Start the timer */
(void)phLlcNfc_StartTimers (PH_LLCNFC_GUARDTIMER,
ps_frame_info->n_s);
/* "sent_frame_type is updated" only if the data is
written to the lower layer */
ps_frame_info->sent_frame_type = user_i_frame;
}
}
}
}
return result;
}
NFCSTATUS
phLlcNfc_H_SendRejectedIFrame (
phLlcNfc_Context_t *psLlcCtxt,
phLlcNfc_StoreIFrame_t *psListInfo,
uint8_t ns_rejected
)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phLlcNfc_Frame_t *ps_frame_info = NULL;
phLlcNfc_LlcPacket_t s_create_packet;
phLlcNfc_LlcPacket_t *ps_get_packet = NULL;
phLlcNfc_Payload_t *ps_llc_payload = NULL;
phLlcNfc_StoreIFrame_t *ps_store_frame = NULL;
uint8_t llc_header = 0;
uint8_t length = 0;
if ((NULL == psLlcCtxt) || (NULL == psListInfo))
{
result = PHNFCSTVAL (CID_NFC_LLC, NFCSTATUS_INVALID_PARAMETER);
}
else if (0 == psListInfo->winsize_cnt)
{
result = PHNFCSTVAL (CID_NFC_LLC, NFCSTATUS_NOT_ALLOWED);
}
else
{
ps_frame_info = &(psLlcCtxt->s_frameinfo);
ps_store_frame = &(ps_frame_info->s_send_store);
if (ns_rejected < (uint8_t)(ps_store_frame->winsize_cnt +
ps_store_frame->start_pos))
{
/* To send rejected frame, first thing shall be done is
windows size count shall be checked. if the
start position
*/
if (invalid_frame !=
ps_store_frame->s_llcpacket[ns_rejected].frame_to_send)
{
/* Above check is added to know only if */
result = phLlcNfc_H_IFrameList_Peek (psListInfo, &ps_get_packet,
ns_rejected);
}
else
{
ps_frame_info->rejected_ns = DEFAULT_PACKET_INPUT;
/* Get the stored I frame, only if the new frame is sent
from the upper layer */
result = phLlcNfc_H_SendUserIFrame (psLlcCtxt, psListInfo);
}
}
if (NULL != ps_get_packet)
{
llc_header = ps_get_packet->s_llcbuf.sllcpayload.llcheader;
/* Update n(r) value for the header */
llc_header = (uint8_t)(llc_header | ps_frame_info->n_r);
/* Create the packet */
(void)memcpy ((void *)&(s_create_packet), (void *)ps_get_packet,
sizeof (phLlcNfc_LlcPacket_t));
s_create_packet.s_llcbuf.sllcpayload.llcheader = llc_header;
ps_llc_payload = &(s_create_packet.s_llcbuf.sllcpayload);
/* Length of the complete llc buffer, sent to PN544 */
length = s_create_packet.llcbuf_len;
/* Compute CRC for the created packet */
phLlcNfc_H_ComputeCrc ((uint8_t *)&(s_create_packet.s_llcbuf),
(length - 2),
(uint8_t *)&(ps_llc_payload->llcpayload[(length - 4)]),
(uint8_t *)&(ps_llc_payload->llcpayload[(length - 3)]));
/* Send the i frame */
result = phLlcNfc_Interface_Write (psLlcCtxt,
(uint8_t *)&(s_create_packet.s_llcbuf),
(uint32_t)s_create_packet.llcbuf_len);
ps_frame_info->write_status = result;
if (NFCSTATUS_BUSY == PHNFCSTATUS (result))
{
/* Already a frame is sent and response is waited for the sent frame,
so update the below variable */
ps_frame_info->write_wait_call = (phLlcNfc_eSentFrameType_t)
(((ns_rejected != ps_store_frame->start_pos) &&
(resend_i_frame != ps_frame_info->write_wait_call))?
rejected_i_frame : ps_frame_info->write_wait_call);
}
else
{
/* NFCSTATUS_PENDING means that the no other write is pending, apart
from the present write
Start the timer */
(void)phLlcNfc_StartTimers (PH_LLCNFC_GUARDTIMER, ns_rejected);
/* "sent_frame_type is updated" only if the data is
written to the lower layer. This will be used in the write
response callback and also indicates, what is the frame sent
and why
*/
ps_frame_info->sent_frame_type = rejected_i_frame;
if ((ns_rejected + 1) < ps_frame_info->n_s)
{
ps_frame_info->rejected_ns = (uint8_t)(ns_rejected + 1);
ps_frame_info->write_status = PHNFCSTVAL(CID_NFC_LLC,
NFCSTATUS_BUSY);
if (invalid_frame ==
ps_store_frame->s_llcpacket[ns_rejected].frame_to_send)
{
ps_frame_info->rejected_ns = DEFAULT_PACKET_INPUT;
ps_frame_info->write_wait_call = user_i_frame;
}
else
{
ps_frame_info->write_wait_call = rejected_i_frame;
}
}
else
{
ps_frame_info->rejected_ns = DEFAULT_PACKET_INPUT;
/* This check is added to see that new frame has arrived
from the upper layer */
if (ps_frame_info->n_s < (ps_store_frame->start_pos +
ps_store_frame->winsize_cnt))
{
ps_frame_info->write_wait_call = user_i_frame;
}
}
}
}
}
return result;
}
NFCSTATUS
phLlcNfc_H_SendTimedOutIFrame (
phLlcNfc_Context_t *psLlcCtxt,
phLlcNfc_StoreIFrame_t *psListInfo,
uint8_t frame_to_send
)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phLlcNfc_Frame_t *ps_frame_info = NULL;
phLlcNfc_Timerinfo_t *ps_timer_info = NULL;
phLlcNfc_LlcPacket_t s_create_packet;
phLlcNfc_LlcPacket_t *ps_get_packet = NULL;
phLlcNfc_Payload_t *ps_llc_payload = NULL;
phLlcNfc_StoreIFrame_t *ps_store_frame = NULL;
PHNFC_UNUSED_VARIABLE(frame_to_send);
if((NULL == psLlcCtxt) || (NULL == psListInfo))
{
result = PHNFCSTVAL(CID_NFC_LLC, NFCSTATUS_INVALID_PARAMETER);
}
else if (psListInfo->winsize_cnt == 0)
{
result = PHNFCSTVAL(CID_NFC_LLC, NFCSTATUS_NOT_ALLOWED);
}
else
{
uint8_t llc_header = 0;
uint8_t length = 0;
uint8_t timer_count = 0;
uint8_t timer_index = 0;
uint8_t ns_index = 0;
ps_frame_info = &(psLlcCtxt->s_frameinfo);
ps_timer_info = &(psLlcCtxt->s_timerinfo);
ps_store_frame = &(ps_frame_info->s_send_store);
timer_index = ps_timer_info->index_to_send;
timer_count = ps_timer_info->guard_to_count;
ns_index = ps_timer_info->timer_ns_value[timer_index];
PH_LLCNFC_DEBUG("SEND TIMEOUT CALL WIN SIZE CNT : 0x%02X\n", ps_store_frame->winsize_cnt);
PH_LLCNFC_DEBUG("SEND TIMEOUT CALL START POS : 0x%02X\n", ps_store_frame->start_pos);
PH_LLCNFC_DEBUG("SEND TIMEOUT CALL N S value : 0x%02X\n", ps_frame_info->n_s);
PH_LLCNFC_DEBUG("SEND TIMEOUT TIMER INDEX : 0x%02X\n", timer_index);
PH_LLCNFC_DEBUG("SEND TIMEOUT CALL frame type : 0x%02X\n", ps_timer_info->frame_type[timer_index]);
if (resend_i_frame == ps_timer_info->frame_type[timer_index])
{
/* Get the stored I frame */
result = phLlcNfc_H_IFrameList_Peek (psListInfo, &ps_get_packet,
ns_index);
}
PH_LLCNFC_DEBUG("SEND TIMEOUT CALL Packet : 0x%p\n", ps_get_packet);
if (NULL != ps_get_packet)
{
llc_header = ps_get_packet->s_llcbuf.sllcpayload.llcheader;
/* Update n(r) value for the header */
llc_header = (uint8_t)(llc_header | ps_frame_info->n_r);
/* create the packet */
(void)memcpy ((void *)&(s_create_packet), (void *)ps_get_packet,
sizeof (phLlcNfc_LlcPacket_t));
s_create_packet.s_llcbuf.sllcpayload.llcheader = llc_header;
ps_llc_payload = &(s_create_packet.s_llcbuf.sllcpayload);
/* Length of the complete llc buffer, sent to PN544 */
length = s_create_packet.llcbuf_len;
/* Compute CRC */
phLlcNfc_H_ComputeCrc((uint8_t *)&(s_create_packet.s_llcbuf),
(length - 2),
(uint8_t *)&(ps_llc_payload->llcpayload[(length - 4)]),
(uint8_t *)&(ps_llc_payload->llcpayload[(length - 3)]));
/* Send the i frame */
result = phLlcNfc_Interface_Write (psLlcCtxt,
(uint8_t *)&(s_create_packet.s_llcbuf),
(uint32_t)s_create_packet.llcbuf_len);
ps_frame_info->write_status = result;
PH_LLCNFC_DEBUG("SEND TIMEOUT CALL Write status : 0x%02X\n", result);
if (NFCSTATUS_BUSY == PHNFCSTATUS (result))
{
ps_frame_info->write_wait_call = resend_i_frame;
}
else
{
/* result = NFCSTATUS_PENDING and
Timer is not started because the remaining timer
will be running */
uint16_t time_out_value = 0;
/* Each frame has the send count, so increment this
as soon as the frame is sent */
ps_timer_info->iframe_send_count[timer_index] = (uint8_t)
(ps_timer_info->iframe_send_count[timer_index] + 1);
PH_LLCNFC_DEBUG("SEND TIMEOUT CALL timer index : 0x%02X\n", timer_index);
if (timer_index > 0)
{
PH_LLCNFC_DEBUG("SEND TIMEOUT CALL GUARD TO VALUE : 0x%02X\n", ps_timer_info->guard_to_value[(timer_index - 1)]);
/* Copy the maximum time-out value. */
time_out_value = (uint16_t)
((ps_timer_info->guard_to_value[(timer_index - 1)] >=
PH_LLCNFC_GUARD_TO_VALUE) ?
(ps_timer_info->guard_to_value[(timer_index - 1)] +
PH_LLCNFC_RESOLUTION):
PH_LLCNFC_GUARD_TO_VALUE);
}
else
{
/* If the timer_index is 0 means, the previous timed out
frame is the last frame in the list */
time_out_value = (uint16_t)
((ps_timer_info->guard_to_value[(timer_count - 1)] >=
PH_LLCNFC_GUARD_TO_VALUE) ?
(ps_timer_info->guard_to_value[(timer_count - 1)] +
PH_LLCNFC_RESOLUTION):
PH_LLCNFC_GUARD_TO_VALUE);
}
ps_timer_info->guard_to_value[timer_index] = time_out_value;
ps_frame_info->sent_frame_type = resend_i_frame;
ps_timer_info->frame_type[timer_index] = invalid_frame;
PH_LLCNFC_DEBUG("SEND TIMEOUT CALL Next frame type : 0x%02X\n", ps_timer_info->frame_type[((timer_index + 1) % PH_LLCNFC_MAX_ACK_GUARD_TIMER)]);
/* Now check if next timer has expired, if yes,
set the index to next, on receiving the write response
callback for this send, then next frame can be sent */
if (resend_i_frame ==
ps_timer_info->frame_type[((timer_index + 1) %
PH_LLCNFC_MAX_ACK_GUARD_TIMER)])
{
/* If next frame has to be sent, then update write wait */
ps_frame_info->write_status = NFCSTATUS_BUSY;
ps_frame_info->write_wait_call = resend_i_frame;
ps_timer_info->index_to_send = (uint8_t)
((timer_index + 1) %
PH_LLCNFC_MAX_ACK_GUARD_TIMER);
}
else
{
/* Timer is not expired,
Now, Check if the new frame is ready to be sent, if yes,
then update the variable */
if (
(ps_frame_info->n_s != ((ps_store_frame->winsize_cnt +
ps_store_frame->start_pos) % PH_LLCNFC_MOD_NS_NR))
)
{
ps_frame_info->write_status = PHNFCSTVAL (CID_NFC_LLC,
NFCSTATUS_BUSY);
ps_frame_info->write_wait_call = user_i_frame;
}
}
#if 0
result = phLlcNfc_StartTimers (PH_LLCNFC_GUARDTIMER,
((llc_header >>
PH_LLCNFC_NS_START_BIT_POS) |
MAX_NS_NR_VALUE));
#endif /* #if 0 */
}
}
else
{
if (
(ps_frame_info->n_s != ((ps_store_frame->winsize_cnt +
ps_store_frame->start_pos) % PH_LLCNFC_MOD_NS_NR))
)
{
ps_frame_info->write_status = PHNFCSTVAL (CID_NFC_LLC,
NFCSTATUS_BUSY);
ps_frame_info->write_wait_call = user_i_frame;
}
}
}
return result;
}
void
phLlcNfc_H_ProcessIFrame (
phLlcNfc_Context_t *psLlcCtxt
)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
uint8_t ns_index = 0;
#if defined (LLC_SEND_RR_ACK)
/* uint8_t nr_index = 0; */
#endif /* #if defined (LLC_SEND_RR_ACK) */
phLlcNfc_Frame_t *ps_frame_info = NULL;
phLlcNfc_StoreIFrame_t *ps_store_frame = NULL;
phLlcNfc_LlcPacket_t *ps_recv_pkt = NULL;
phLlcNfc_LlcCmd_t cmdtype = phLlcNfc_e_error;
phLlcNfc_eSentFrameType_t eframe_type = invalid_frame;
uint8_t dont_send_s_frame = FALSE;
uint8_t no_of_del_frames = 0;
phNfc_sCompletionInfo_t notifyinfo = {0,0,0};
#ifdef RECV_NR_CHECK_ENABLE
uint8_t recvd_nr = 0;
#endif /* #ifdef RECV_NR_CHECK_ENABLE */
ps_frame_info = &(psLlcCtxt->s_frameinfo);
ps_store_frame = &(ps_frame_info->s_send_store);
ps_recv_pkt = &(ps_frame_info->s_recvpacket);
PHNFC_UNUSED_VARIABLE(result);
/* Received buffer, N(S) value */
ns_index = (uint8_t)GET_BITS8(
ps_recv_pkt->s_llcbuf.sllcpayload.llcheader,
PH_LLCNFC_NS_START_BIT_POS,
PH_LLCNFC_NR_NS_NO_OF_BITS);
PH_LLCNFC_DEBUG("NS START POS BEFORE DEL : 0x%02X\n", ps_store_frame->start_pos);
PH_LLCNFC_DEBUG("WIN SIZE BEFORE DEL : 0x%02X\n", ps_store_frame->winsize_cnt);
/* Correct frame is received, so remove the stored i frame info */
no_of_del_frames = phLlcNfc_H_UpdateIFrameList (ps_frame_info,
&(ps_frame_info->s_send_store));
PH_LLCNFC_DEBUG("NS START POS AFTER DEL : 0x%02X\n", ps_store_frame->start_pos);
PH_LLCNFC_DEBUG("WIN SIZE AFTER DEL : 0x%02X\n", ps_store_frame->winsize_cnt);
#ifdef RECV_NR_CHECK_ENABLE
recvd_nr = (uint8_t)GET_BITS8(
ps_recv_pkt->s_llcbuf.sllcpayload.llcheader,
PH_LLCNFC_NR_START_BIT_POS,
PH_LLCNFC_NR_NS_NO_OF_BITS);
if (((ps_frame_info->n_s > recvd_nr) &&
(0 == ((ps_frame_info->n_s + 1) % PH_LLCNFC_MOD_NS_NR)))
|| (recvd_nr > ps_frame_info->n_s))
#else /* #ifdef RECV_NR_CHECK_ENABLE */
if (no_of_del_frames > 0)
#endif /* #ifdef RECV_NR_CHECK_ENABLE */
{
phLlcNfc_StopTimers (PH_LLCNFC_GUARDTIMER, no_of_del_frames);
}
/* Received buffer, N(S) value = N(R) of host (our
structure) then send RR type of s frame else send
REJ type of s frame */
if ((ns_index == ps_frame_info->n_r)
#if defined (LLC_SEND_RR_ACK)
|| ((ns_index < ps_frame_info->n_r) &&
((ps_frame_info->n_r - ns_index) < ps_frame_info->window_size))
|| ((ns_index > ps_frame_info->n_r) &&
((ns_index - ps_frame_info->n_r) > ps_frame_info->window_size))
#endif /* #if defined (LLC_SEND_RR_ACK) */
)
{
PH_LLCNFC_PRINT(" Type bits of S frame to be sent is RR \n");
ps_frame_info->recv_error_count = 0;
ps_frame_info->send_error_count = 0;
psLlcCtxt->recvbuf_length = (ps_recv_pkt->llcbuf_len -
PH_LLCNFC_LEN_APPEND);
(void)memcpy ((void *)psLlcCtxt->precv_buf, (void *)(
ps_recv_pkt->s_llcbuf.sllcpayload.llcpayload),
psLlcCtxt->recvbuf_length);
#if defined (LLC_SEND_RR_ACK)
if (((ns_index < ps_frame_info->n_r) &&
((ps_frame_info->n_r - ns_index) < ps_frame_info->window_size))
|| ((ns_index > ps_frame_info->n_r) &&
((ns_index - ps_frame_info->n_r) > ps_frame_info->window_size)))
{
ps_frame_info->n_r = ((ns_index + 1)
% PH_LLCNFC_MOD_NS_NR);
}
else
#endif /* #if defined (LLC_SEND_RR_ACK) */
{
/* Update the N(R) value in I and S frame context */
ps_frame_info->n_r = ((ps_frame_info->n_r + 1)
% PH_LLCNFC_MOD_NS_NR);
#ifdef PIGGY_BACK
ps_frame_info->resp_recvd_count = (uint8_t)
(ps_frame_info->resp_recvd_count + 1);
#endif /* #ifdef PIGGY_BACK */
}
if (NFCSTATUS_BUSY == PHNFCSTATUS (ps_frame_info->write_status))
{
/* Any how write cannot be done and some frame is ready to be sent
so this frame will act as the ACK */
result = phLlcNfc_H_WriteWaitCall (psLlcCtxt);
}
else
{
if (
(ps_frame_info->n_s != ((ps_store_frame->winsize_cnt +
ps_store_frame->start_pos) % PH_LLCNFC_MOD_NS_NR))
)
{
/* If user has sent a frame and DAL write is busy, then
it has to be sent */
result = phLlcNfc_H_SendUserIFrame (psLlcCtxt, ps_store_frame);
}
}
if (NFCSTATUS_PENDING == result)
{
dont_send_s_frame = TRUE;
#ifdef LLC_UPP_LAYER_NTFY_WRITE_RSP_CB
phLlcNfc_H_SendInfo (psLlcCtxt);
#endif /* #ifdef LLC_UPP_LAYER_NTFY_WRITE_RSP_CB */
}
else
{
cmdtype = phLlcNfc_e_rr;
/* If i frame is sent from the stored list, it got the correct
acknowledge i frame, so now for an i frame , s frame acknowledge
is sent */
eframe_type = ((resend_i_frame == ps_frame_info->sent_frame_type)?
resend_s_frame : s_frame);
}
#ifdef PIGGY_BACK
phLlcNfc_H_SendInfo (psLlcCtxt);
#endif /* #ifdef PIGGY_BACK */
}
else
{
ps_frame_info->send_error_count = (uint8_t)
(ps_frame_info->send_error_count + 1);
#ifdef LLC_SEND_ERROR_COUNT
if (ps_frame_info->send_error_count < RECV_ERROR_FRAME_COUNT)
#endif /* #ifdef LLC_SEND_ERROR_COUNT */
{
#ifdef LLC_RR_INSTEAD_OF_REJ
if (((ps_frame_info->n_r > 0) && (ns_index == (ps_frame_info->n_r - 1)))
|| ((0 == ps_frame_info->n_r) &&
(ns_index == (PH_LLCNFC_MOD_NS_NR - 1))))
{
cmdtype = phLlcNfc_e_rr;
eframe_type = rej_rr_s_frame;
}
else
#endif /* #ifdef LLC_RR_INSTEAD_OF_REJ */
{
cmdtype = phLlcNfc_e_rej;
eframe_type = ((resend_i_frame == ps_frame_info->sent_frame_type)?
resend_rej_s_frame : reject_s_frame);
}
}
#ifdef LLC_SEND_ERROR_COUNT
else
{
#ifdef LLC_RSET_INSTEAD_OF_EXCEPTION
result = phLlcNfc_H_SendRSETFrame (psLlcCtxt);
#else /* #ifdef LLC_RSET_INSTEAD_OF_EXCEPTION */
dont_send_s_frame = TRUE;
PH_LLCNFC_DEBUG("SEND ERROR COUNT : 0x%02X\n", ps_frame_info->send_error_count);
/* Error count has reached the limit, raise exception */
notifyinfo.status = PHNFCSTVAL(CID_NFC_LLC,
NFCSTATUS_BOARD_COMMUNICATION_ERROR);
#if 0
phOsalNfc_RaiseException(phOsalNfc_e_UnrecovFirmwareErr,1);
#endif /* #if 0 */
/* Resend done, no answer from the device */
psLlcCtxt->cb_for_if.notify (
psLlcCtxt->cb_for_if.pif_ctxt,
psLlcCtxt->phwinfo,
NFC_NOTIFY_DEVICE_ERROR,
&notifyinfo);
#endif /* #ifdef LLC_RSET_INSTEAD_OF_EXCEPTION */
}
#endif /* #ifdef LLC_SEND_ERROR_COUNT */
}
#ifdef LLC_RELEASE_FLAG
if (FALSE == g_release_flag)
#endif /* #ifdef LLC_RELEASE_FLAG */
{
(void)phLlcNfc_Interface_Read(psLlcCtxt,
PH_LLCNFC_READWAIT_OFF,
&(ps_recv_pkt->s_llcbuf.llc_length_byte),
(uint8_t)PH_LLCNFC_BYTES_INIT_READ);
#ifdef PIGGY_BACK
/* Check if any write call is performed or not */
if (NFCSTATUS_PENDING != result)
{
/* No write is performed, So, now check */
if (NFCSTATUS_BUSY == PHNFCSTATUS (ps_frame_info->write_status))
{
/* Any how write cannot be done and some frame is ready to be sent
so this frame will act as the ACK */
result = phLlcNfc_H_WriteWaitCall (psLlcCtxt);
}
}
if (NFCSTATUS_PENDING != result)
{
if (ps_frame_info->window_size == ps_frame_info->resp_recvd_count)
{
phLlcNfc_LlcPacket_t s_packet_info;
/* Create S frame */
(void)phLlcNfc_H_CreateSFramePayload (ps_frame_info, &(s_packet_info), cmdtype);
result = phLlcNfc_Interface_Write(psLlcCtxt,
(uint8_t *)&(s_packet_info.s_llcbuf),
(uint32_t)(s_packet_info.llcbuf_len));
if (0 == ps_frame_info->send_error_count)
{
ps_frame_info->write_wait_call = invalid_frame;
}
ps_frame_info->sent_frame_type = eframe_type;
}
else
{
result = phLlcNfc_StartTimers (PH_LLCNFC_ACKTIMER, 0);
}
}
#else /* #ifdef PIGGY_BACK */
if ((TRUE != ps_frame_info->write_pending) &&
(PH_LLCNFC_READPEND_REMAIN_BYTE != ps_frame_info->read_pending) &&
(FALSE == dont_send_s_frame))
{
phLlcNfc_LlcPacket_t s_packet_info = {0};
/* Create S frame */
(void)phLlcNfc_H_CreateSFramePayload (ps_frame_info, &(s_packet_info), cmdtype);
result = phLlcNfc_Interface_Write(psLlcCtxt,
(uint8_t *)&(s_packet_info.s_llcbuf),
(uint32_t)(s_packet_info.llcbuf_len));
if (0 == ps_frame_info->send_error_count)
{
ps_frame_info->write_wait_call = invalid_frame;
}
ps_frame_info->sent_frame_type = eframe_type;
}
#endif /* #ifdef PIGGY_BACK */
}
return ;
}
static
NFCSTATUS
phLlcNfc_H_ProcessUFrame (
phLlcNfc_Context_t *psLlcCtxt
)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phLlcNfc_Frame_t *ps_frame_info = NULL;
phLlcNfc_LlcPacket_t *ps_uframe_pkt = NULL;
#ifdef LLC_URSET_NO_DELAY
phNfc_sCompletionInfo_t notifyinfo = {0,0,0};
#else /* #ifdef LLC_URSET_NO_DELAY */
uint32_t delay_timer_id =
PH_OSALNFC_INVALID_TIMER_ID;
#endif /* #ifdef LLC_URSET_NO_DELAY */
uint8_t cmdtype = phLlcNfc_e_error;
phLlcNfc_StopTimers(PH_LLCNFC_CONNECTIONTIMER, 0);
ps_frame_info = &(psLlcCtxt->s_frameinfo);
ps_uframe_pkt = &(ps_frame_info->s_recvpacket);
/* Check the command type */
cmdtype = (ps_uframe_pkt->s_llcbuf.sllcpayload.llcheader &
PH_LLCNFC_U_FRAME_MODIFIER_MASK);
PHNFC_UNUSED_VARIABLE(result);
switch(cmdtype)
{
case phLlcNfc_e_rset:
{
psLlcCtxt->s_frameinfo.rset_recvd = TRUE;
/* command type is RSET, so update the U frame parameters */
result = phLlcNfc_H_Update_ReceivedRSETInfo (ps_frame_info,
ps_uframe_pkt->s_llcbuf.sllcpayload);
/* Create a UA frame */
result = phLlcNfc_H_CreateUFramePayload(psLlcCtxt,
ps_uframe_pkt,
&(ps_uframe_pkt->llcbuf_len),
phLlcNfc_e_ua);
if (NFCSTATUS_SUCCESS == result)
{
/* Call DAL write */
result = phLlcNfc_Interface_Write( psLlcCtxt,
(uint8_t*)&(ps_uframe_pkt->s_llcbuf),
(uint32_t)ps_uframe_pkt->llcbuf_len);
phLlcNfc_H_ResetFrameInfo(psLlcCtxt);
ps_frame_info->write_status = result;
ps_frame_info->write_wait_call = invalid_frame;
if (NFCSTATUS_PENDING == result)
{
ps_frame_info->sent_frame_type =
((ps_frame_info->sent_frame_type != init_u_rset_frame) ?
u_a_frame : init_u_a_frame);
}
else
{
if (NFCSTATUS_BUSY == PHNFCSTATUS(result))
{
ps_frame_info->write_wait_call =
((ps_frame_info->sent_frame_type != init_u_rset_frame) ?
u_a_frame : init_u_a_frame);
result = NFCSTATUS_PENDING;
}
}
}
break;
}
case phLlcNfc_e_ua:
{
phLlcNfc_H_ResetFrameInfo (psLlcCtxt);
/* Add timer here, to delay the next command to the PN544 */
#ifdef LLC_URSET_NO_DELAY
if (ps_frame_info->s_send_store.winsize_cnt > 0)
{
#if 0
/* Resend I frame */
result = phLlcNfc_H_SendTimedOutIFrame (psLlcCtxt,
&(ps_frame_info->s_send_store, 0);
#else
result = phLlcNfc_H_SendUserIFrame (psLlcCtxt,
&(ps_frame_info->s_send_store));
#endif /* #if 0 */
}
else
{
if ((init_u_rset_frame == ps_frame_info->sent_frame_type) &&
(NULL != psLlcCtxt->cb_for_if.notify))
{
ps_frame_info->sent_frame_type = write_resp_received;
notifyinfo.status = NFCSTATUS_SUCCESS;
/* Send the notification to the upper layer */
psLlcCtxt->cb_for_if.notify(
psLlcCtxt->cb_for_if.pif_ctxt,
psLlcCtxt->phwinfo,
NFC_NOTIFY_INIT_COMPLETED,
&notifyinfo);
}
}
#else /* #ifdef LLC_URSET_NO_DELAY */
delay_timer_id = phOsalNfc_Timer_Create ();
phOsalNfc_Timer_Start (delay_timer_id, LLC_URSET_DELAY_TIME_OUT,
phLlcNfc_URSET_Delay_Notify, (void*)0);
#endif /* #ifdef LLC_URSET_NO_DELAY */
break;
}
default:
{
result = PHNFCSTVAL(CID_NFC_LLC,
NFCSTATUS_INVALID_FORMAT);
break;
}
}
return result;
}
static
void
phLlcNfc_H_ProcessSFrame (
phLlcNfc_Context_t *psLlcCtxt)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
uint8_t cmdtype = phLlcNfc_e_error;
#if 0
prev_win_count = 0;
#endif /* #if 0 */
phNfc_sTransactionInfo_t compinfo = {0, 0, 0, 0, 0};
phLlcNfc_Frame_t *ps_frame_info = NULL;
phLlcNfc_StoreIFrame_t *ps_store_frame = NULL;
phLlcNfc_LlcPacket_t *ps_recv_pkt = NULL;
uint8_t no_of_del_frames = 0;
phNfc_sCompletionInfo_t notifyinfo = {0,0,0};
ps_frame_info = &(psLlcCtxt->s_frameinfo);
ps_recv_pkt = &(ps_frame_info->s_recvpacket);
ps_store_frame = &(ps_frame_info->s_send_store);
cmdtype = (ps_recv_pkt->s_llcbuf.sllcpayload.llcheader &
PH_LLCNFC_S_FRAME_TYPE_MASK);
PHNFC_UNUSED_VARIABLE(result);
PH_LLCNFC_DEBUG("NS START POS BEFORE DEL : 0x%02X\n", ps_store_frame->start_pos);
PH_LLCNFC_DEBUG("WIN SIZE BEFORE DEL : 0x%02X\n", ps_store_frame->winsize_cnt);
/* Correct frame is received, so remove the
stored i frame info for the acknowledged frames */
no_of_del_frames = phLlcNfc_H_UpdateIFrameList (ps_frame_info,
&(ps_frame_info->s_send_store));
PH_LLCNFC_DEBUG("NS START POS AFTER DEL : 0x%02X\n", ps_store_frame->start_pos);
PH_LLCNFC_DEBUG("WIN SIZE AFTER DEL : 0x%02X\n", ps_store_frame->winsize_cnt);
#if 0
prev_win_count = ps_frame_info->s_send_store.winsize_cnt;
#endif /* #if 0 */
/* Pend the read */
result = phLlcNfc_Interface_Read (psLlcCtxt,
PH_LLCNFC_READWAIT_OFF,
&(ps_recv_pkt->s_llcbuf.llc_length_byte),
(uint8_t)PH_LLCNFC_BYTES_INIT_READ);
switch(cmdtype)
{
case phLlcNfc_e_rr:
case phLlcNfc_e_rej:
{
/* RR frame received */
phLlcNfc_StopTimers (PH_LLCNFC_GUARDTIMER, no_of_del_frames);
if (phLlcNfc_e_rr == cmdtype)
{
ps_frame_info->recv_error_count = 0;
ps_frame_info->send_error_count = 0;
}
else
{
ps_frame_info->recv_error_count = (uint8_t)
(ps_frame_info->recv_error_count + 1);
}
if (ps_frame_info->recv_error_count >= RECV_ERROR_FRAME_COUNT)
{
/* Do nothing */
}
else if (NFCSTATUS_BUSY == PHNFCSTATUS(ps_frame_info->write_status))
{
result = phLlcNfc_H_WriteWaitCall (psLlcCtxt);
}
else
{
if (
(ps_frame_info->n_s != ((ps_store_frame->winsize_cnt +
ps_store_frame->start_pos) % PH_LLCNFC_MOD_NS_NR))
)
{
/* If user has sent a frame and DAL write is busy, then
it has to be sent */
result = phLlcNfc_H_SendUserIFrame (psLlcCtxt, ps_store_frame);
}
}
if ((0 != psLlcCtxt->send_cb_len) &&
(ps_store_frame->winsize_cnt < ps_frame_info->window_size))
{
/* Due to the window size count (i.e., count has reached
the limit), send completion was not sent for the previous
send from the upper layer. So to allow next send from the
upper layer, send completion is called */
compinfo.length = (uint16_t)psLlcCtxt->send_cb_len;
compinfo.status = NFCSTATUS_SUCCESS;
if (NULL != psLlcCtxt->cb_for_if.send_complete)
{
psLlcCtxt->send_cb_len = 0;
/* Call the send callback, if the window size
count becomes less than actual window size */
psLlcCtxt->cb_for_if.send_complete (
psLlcCtxt->cb_for_if.pif_ctxt,
psLlcCtxt->phwinfo, &compinfo);
}
}
break;
}
#if 0
case phLlcNfc_e_rej:
{
ps_frame_info->recv_error_count = (uint8_t)
(ps_frame_info->recv_error_count + 1);
/* RR frame received */
phLlcNfc_StopTimers (PH_LLCNFC_GUARDTIMER, no_of_del_frames);
if (ps_frame_info->recv_error_count < RECV_ERROR_FRAME_COUNT)
{
/* Below check is added because if PN544 sends REJ to a frame, but
the next frame has already been sent from PN544, then
Send the user I frame */
result = phLlcNfc_H_SendUserIFrame (psLlcCtxt, ps_store_frame);
}
break;
}
#endif /* #if 0 */
case phLlcNfc_e_rnr:
{
phLlcNfc_StopAllTimers ();
ps_frame_info->recv_error_count = (uint8_t)
(ps_frame_info->recv_error_count + 1);
break;
}
case phLlcNfc_e_srej:
default:
{
ps_frame_info->recv_error_count = (uint8_t)
(ps_frame_info->recv_error_count + 1);
result = PHNFCSTVAL (CID_NFC_LLC,
NFCSTATUS_INVALID_FORMAT);
break;
}
}
if (ps_frame_info->recv_error_count >= RECV_ERROR_FRAME_COUNT)
{
#ifdef LLC_RSET_INSTEAD_OF_EXCEPTION
result = phLlcNfc_H_SendRSETFrame (psLlcCtxt);
#else /* #ifdef LLC_RSET_INSTEAD_OF_EXCEPTION */
PH_LLCNFC_DEBUG("RECV ERROR COUNT : 0x%02X\n", ps_frame_info->recv_error_count);
/* Raise the exception for CRC error received from the */
notifyinfo.status = PHNFCSTVAL(CID_NFC_LLC,
NFCSTATUS_BOARD_COMMUNICATION_ERROR);
#if 0
phOsalNfc_RaiseException(phOsalNfc_e_UnrecovFirmwareErr,1);
#endif /* #if 0 */
/* Resend done, no answer from the device */
psLlcCtxt->cb_for_if.notify (
psLlcCtxt->cb_for_if.pif_ctxt,
psLlcCtxt->phwinfo,
NFC_NOTIFY_DEVICE_ERROR,
&notifyinfo);
#endif /* #ifdef LLC_RSET_INSTEAD_OF_EXCEPTION */
}
return ;
}
void
phLlcNfc_H_ComputeCrc(
uint8_t *pData,
uint8_t length,
uint8_t *pCrc1,
uint8_t *pCrc2
)
{
uint8_t crc_byte = 0,
index = 0;
uint16_t crc = 0;
#ifdef CRC_A
crc = 0x6363; /* ITU-V.41 */
#else
crc = 0xFFFF; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */
#endif /* #ifdef CRC_A */
do
{
crc_byte = pData[index];
phLlcNfc_H_UpdateCrc(crc_byte, &crc);
index++;
} while (index < length);
#ifndef INVERT_CRC
crc = ~crc; /* ISO/IEC 13239 (formerly ISO/IEC 3309) */
#endif /* #ifndef INVERT_CRC */
*pCrc1 = (uint8_t) (crc & 0xFF);
*pCrc2 = (uint8_t) ((crc >> 8) & 0xFF);
return;
}
static
void
phLlcNfc_H_UpdateCrc(
uint8_t crcByte,
uint16_t *pCrc
)
{
crcByte = (crcByte ^ (uint8_t)((*pCrc) & 0x00FF));
crcByte = (crcByte ^ (uint8_t)(crcByte << 4));
*pCrc = (*pCrc >> 8) ^ ((uint16_t)crcByte << 8) ^
((uint16_t)crcByte << 3) ^
((uint16_t)crcByte >> 4);
}
NFCSTATUS
phLlcNfc_H_StoreIFrame (
phLlcNfc_StoreIFrame_t *psList,
phLlcNfc_LlcPacket_t sPacketInfo
)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
uint8_t ns_index = 0,
llc_header = 0;
if ((NULL == psList) || (0 == sPacketInfo.llcbuf_len) ||
(PH_LLCNFC_I_HEADER_INIT !=
(sPacketInfo.s_llcbuf.sllcpayload.llcheader &
PH_LLCNFC_I_FRM_HEADER_MASK)))
{
result = PHNFCSTVAL(CID_NFC_LLC, NFCSTATUS_INVALID_PARAMETER);
}
else
{
/* Get the index from the start index */
if(psList->winsize_cnt > 0)
{
ns_index = (uint8_t)((psList->start_pos + psList->winsize_cnt) %
PH_LLCNFC_MOD_NS_NR);
}
else
{
ns_index = psList->start_pos;
}
llc_header = (uint8_t)(PH_LLCNFC_I_HEADER_INIT | (ns_index <<
PH_LLCNFC_NS_START_BIT_POS));
sPacketInfo.s_llcbuf.sllcpayload.llcheader = llc_header;
(void)memcpy (&(psList->s_llcpacket[ns_index]),
&(sPacketInfo), sizeof(phLlcNfc_LlcPacket_t));
/* This variable says that LLC has to send complete
callback for stored I frame */
psList->s_llcpacket[ns_index].frame_to_send = invalid_frame;
psList->winsize_cnt++;
}
return result;
}
static
void
phLlcNfc_H_DeleteIFrame (
phLlcNfc_StoreIFrame_t *psList
)
{
if (NULL != psList)
{
(void)memset( &(psList->s_llcpacket[psList->start_pos]),
0, sizeof(phLlcNfc_LlcPacket_t));
/* Go to next N(S) position */
psList->start_pos = ((psList->start_pos + 1) %
PH_LLCNFC_MOD_NS_NR);
if (psList->winsize_cnt > 0)
{
psList->winsize_cnt--;
}
}
}
static
NFCSTATUS
phLlcNfc_H_IFrameList_Peek (
phLlcNfc_StoreIFrame_t *psList,
phLlcNfc_LlcPacket_t **psPacketinfo,
uint8_t position
)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
uint8_t index = 0;
*psPacketinfo = NULL;
if ((NULL != psList) && (psList->winsize_cnt > 0))
{
result = NFCSTATUS_SUCCESS;
if ((position < (psList->start_pos + psList->winsize_cnt)) ||
(DEFAULT_PACKET_INPUT == position))
{
index = (uint8_t)((DEFAULT_PACKET_INPUT == position) ?
psList->start_pos : position);
*psPacketinfo = &(psList->s_llcpacket[index]);
}
}
return result;
}
NFCSTATUS
phLlcNfc_H_ProRecvFrame (
phLlcNfc_Context_t *psLlcCtxt
)
{
NFCSTATUS result = PHNFCSTVAL(CID_NFC_LLC,
NFCSTATUS_INVALID_PARAMETER);
phLlcNfc_FrameType_t frame_type = phLlcNfc_eErr_frame;
#ifdef LLC_DATA_BYTES
uint8_t *print_buf = (uint8_t *)
&(psLlcCtxt->s_frameinfo.s_recvpacket.s_llcbuf);
uint8_t buf_len =
psLlcCtxt->s_frameinfo.s_recvpacket.llcbuf_len;
PH_LLCNFC_STRING("** Response ");
#endif /* LLC_DATA_BYTES */
if (NULL != psLlcCtxt)
{
result = NFCSTATUS_SUCCESS;
/* Get the received frame type */
frame_type = phLlcNfc_H_ChkGetLlcFrameType(
psLlcCtxt->s_frameinfo.s_recvpacket.s_llcbuf.sllcpayload.llcheader);
/* Depending on the received frame type, process the
received buffer */
switch(frame_type)
{
case phLlcNfc_eU_frame:
{
PH_LLCNFC_PRINT("U frame received \n");
PH_LLCNFC_STRING("U frame ");
PH_LLCNFC_PRINT_DATA(print_buf, buf_len);
PH_LLCNFC_STRING(";\n");
result = phLlcNfc_H_ProcessUFrame(psLlcCtxt);
break;
}
case phLlcNfc_eI_frame:
{
PH_LLCNFC_PRINT("I frame received \n");
PH_LLCNFC_STRING("I frame ");
PH_LLCNFC_PRINT_DATA(print_buf, buf_len);
PH_LLCNFC_STRING(";\n");
phLlcNfc_H_ProcessIFrame(psLlcCtxt);
break;
}
case phLlcNfc_eS_frame:
{
PH_LLCNFC_PRINT("S frame received \n");
PH_LLCNFC_STRING("S frame ");
PH_LLCNFC_PRINT_DATA(print_buf, buf_len);
PH_LLCNFC_STRING(";\n");
phLlcNfc_H_ProcessSFrame(psLlcCtxt);
break;
}
case phLlcNfc_eErr_frame:
default:
{
PH_LLCNFC_PRINT("Error frame received \n");
result = PHNFCSTVAL(CID_NFC_LLC, NFCSTATUS_INVALID_FORMAT);
break;
}
}
}
return result;
}
#ifdef CRC_ERROR_REJ
NFCSTATUS
phLlcNfc_H_SendRejectFrame(
phLlcNfc_Context_t *psLlcCtxt
)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phLlcNfc_LlcPacket_t s_packet_info = {0};
result = phLlcNfc_H_CreateSFramePayload(
&(psLlcCtxt->s_frameinfo),
&(s_packet_info),
phLlcNfc_e_rej);
/* Send the "S" frame to the lower layer */
result = phLlcNfc_Interface_Write(psLlcCtxt,
(uint8_t *)&(s_packet_info.s_llcbuf),
(uint32_t)(s_packet_info.llcbuf_len));
if (NFCSTATUS_PENDING == result)
{
/* Increment the retry count of the reject frame */
psLlcCtxt->s_frameinfo.recv_error_count =
(psLlcCtxt->s_frameinfo.recv_error_count + 1);
}
return result;
}
#endif /* #ifdef CRC_ERROR_REJ */
static
void
phLlcNfc_H_ResetFrameInfo (
phLlcNfc_Context_t *psLlcCtxt
)
{
uint8_t i = 0,
win_cnt = 0,
pos = 0,
while_exit = FALSE,
index_flag = FALSE;
phLlcNfc_StoreIFrame_t *ps_send_store = NULL;
phLlcNfc_Buffer_t *ps_buffer = NULL;
ps_send_store = &(psLlcCtxt->s_frameinfo.s_send_store);
win_cnt = ps_send_store->winsize_cnt;
pos = ps_send_store->start_pos;
PH_LLCNFC_PRINT ("\n\nLLC : phLlcNfc_H_ResetFrameInfo called\n\n");
PH_LLCNFC_DEBUG ("\n\nLLC : ps_send_store->start_pos %08X\n", ps_send_store->start_pos);
PH_LLCNFC_DEBUG ("\n\nLLC : ps_send_store->winsize_cnt before reset %08X\n", ps_send_store->winsize_cnt);
if (0 != pos)
{
/* If the start position of the ns = 0, then
no need to shift the stored llc data,
Else it has to be shifted to the first
index of the array */
if(TRUE == ((pos + win_cnt) /
PH_LLCNFC_MAX_I_FRAME_STORE))
{
/* 'i' is the array index, So to store data in the array,
windows size count shall be subtracted by 1 */
i = (win_cnt - 1);
/* if window size > 1 and ns for 2 frames are 7 and 0, then
to reset the ns index to 0, the frames are copied from
the reverse order, so to do it a flag is declared */
index_flag = TRUE;
pos = (((pos - 1) + win_cnt) % PH_LLCNFC_MAX_I_FRAME_STORE);
}
while (FALSE == while_exit)
{
(void)memcpy ((void *)&(ps_send_store->s_llcpacket[i]),
(void *)&(ps_send_store->s_llcpacket[pos]),
sizeof (phLlcNfc_LlcPacket_t));
ps_send_store->s_llcpacket[i].frame_to_send = invalid_frame;
ps_buffer = &(ps_send_store->s_llcpacket[i].s_llcbuf);
/* change n(s) value */
ps_buffer->sllcpayload.llcheader = (uint8_t)
(PH_LLCNFC_I_HEADER_INIT |
(i << PH_LLCNFC_NS_START_BIT_POS));
if(TRUE == index_flag)
{
if(0 == i)
{
while_exit = TRUE;
}
else
{
i = ((i - 1) % PH_LLCNFC_MAX_I_FRAME_STORE);
if (0 == pos)
{
pos = (PH_LLCNFC_MAX_I_FRAME_STORE - 1);
}
else
{
pos = ((pos - 1) % PH_LLCNFC_MAX_I_FRAME_STORE);
}
}
}
else
{
if (i >= win_cnt)
{
while_exit = TRUE;
}
else
{
i = ((i + 1) % PH_LLCNFC_MAX_I_FRAME_STORE);
pos = ((pos + 1) % PH_LLCNFC_MAX_I_FRAME_STORE);
}
}
}
}
psLlcCtxt->s_timerinfo.guard_to_count = 0;
psLlcCtxt->s_timerinfo.timer_flag = 0;
ps_send_store->start_pos = 0;
psLlcCtxt->s_frameinfo.n_r = psLlcCtxt->s_frameinfo.n_s = 0;
if (ps_send_store->winsize_cnt > 0)
{
psLlcCtxt->s_frameinfo.rejected_ns = 0;
}
else
{
psLlcCtxt->s_frameinfo.rejected_ns = DEFAULT_PACKET_INPUT;
}
PH_LLCNFC_DEBUG ("\n\nLLC : ps_send_store->winsize_cnt after reset %08X\n", ps_send_store->winsize_cnt);
return;
}
NFCSTATUS
phLlcNfc_H_WriteWaitCall (
phLlcNfc_Context_t *psLlcCtxt
)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phLlcNfc_StoreIFrame_t *ps_store_info = NULL;
phLlcNfc_Frame_t *ps_frame_info = NULL;
ps_frame_info = &(psLlcCtxt->s_frameinfo);
ps_store_info = &(ps_frame_info->s_send_store);
PH_LLCNFC_PRINT ("\nLLC : phLlcNfc_H_WriteWaitCall call ..\n");
PH_LLCNFC_DEBUG ("\n\nLLC : ps_frame_info->write_wait_call before call %08X\n", ps_frame_info->write_wait_call);
ps_frame_info->write_status = NFCSTATUS_PENDING;
switch (ps_frame_info->write_wait_call)
{
case user_i_frame:
{
ps_frame_info->write_wait_call = invalid_frame;
result = phLlcNfc_H_SendUserIFrame (psLlcCtxt, ps_store_info);
break;
}
case resend_i_frame:
{
ps_frame_info->write_wait_call = invalid_frame;
result = phLlcNfc_H_SendTimedOutIFrame (psLlcCtxt, ps_store_info, 0);
break;
}
case rejected_i_frame:
{
ps_frame_info->write_wait_call = invalid_frame;
result = phLlcNfc_H_SendRejectedIFrame (psLlcCtxt, ps_store_info,
ps_frame_info->rejected_ns);
break;
}
case resend_s_frame:
case reject_s_frame:
case resend_rej_s_frame:
{
ps_frame_info->write_wait_call = invalid_frame;
break;
}
case u_rset_frame:
{
ps_frame_info->write_wait_call = invalid_frame;
result = phLlcNfc_H_SendRSETFrame (psLlcCtxt);
break;
}
default :
{
ps_frame_info->write_wait_call = invalid_frame;
break;
}
}
PH_LLCNFC_DEBUG ("\n\nLLC : ps_frame_info->write_wait_call after call %08X\n", ps_frame_info->write_wait_call);
PH_LLCNFC_PRINT ("\nLLC : phLlcNfc_H_WriteWaitCall end ..\n");
return result;
}
NFCSTATUS
phLlcNfc_H_SendRSETFrame (
phLlcNfc_Context_t *psLlcCtxt
)
{
NFCSTATUS result = NFCSTATUS_SUCCESS;
phLlcNfc_LlcPacket_t s_packet_info;
phLlcNfc_Frame_t *ps_frame_info = NULL;
ps_frame_info = &(psLlcCtxt->s_frameinfo);
result = phLlcNfc_H_CreateUFramePayload(psLlcCtxt,
&(s_packet_info),
&(s_packet_info.llcbuf_len),
phLlcNfc_e_rset);
if (NFCSTATUS_SUCCESS == result)
{
/* Call DAL write */
result = phLlcNfc_Interface_Write(psLlcCtxt,
(uint8_t*)&(s_packet_info.s_llcbuf),
(uint32_t)s_packet_info.llcbuf_len);
}
ps_frame_info->write_status = result;
if (NFCSTATUS_PENDING == result)
{
/* Start the timer */
result = phLlcNfc_StartTimers (PH_LLCNFC_CONNECTIONTIMER, 0);
if (NFCSTATUS_SUCCESS == result)
{
ps_frame_info->sent_frame_type = u_rset_frame;
result = NFCSTATUS_PENDING;
}
}
else
{
ps_frame_info->write_wait_call = u_rset_frame;
}
return result;
}